<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"><title>Podpora pro rámec Stripes v prost\v{r}edí NetBeans IDE</title><link rel="stylesheet" href="docbook.css" type="text/css"><meta name="generator" content="DocBook XSL Stylesheets V1.69.1"><meta name="description" content="Tato diplomová práce se zabývá implementací webového rámce Stripes
      do prostředí NetBeans IDE a klade si za cíl zjednodušit tvorbu webových
      aplikací postavených na platformě Java. NetBeans IDE je vývojové prostředí vycházející z platformy
      NetBeans, která je vysoce modulární a poskytuje tak podporu pro tvorbu
      nových zásuvných modulů. Celá platforma je šířena zdarma a včetně všech
      zdrojových kódů za podpory společnosti Sun. Webový rámec Stripes je nadstavba nad Java Servlet API, která
      usnadňuje tvorbu webových aplikací. Je založen na principu architektury
      MVC a zajišťuje nejběžnější operace potřebné při tvorbě téměř každé
      webové aplikace. Mezi ně patří zpracování formulářů, validace vstupních
      hodnot, zobrazování zpráv uživatelům, řízení toku stránek a další. Rámec
      také obsahuje dobře použitelný systém šablon pro JSP stránky. Propojením NetBeans IDE a Stripes vzniká silný nástroj, pomocí
      nějž lze v krátké době tvořit rozsáhlé, výkonné a přesto snadno
      udržovatelné aplikace založené na platformě Java."><meta name="keywords" content="NetBeans IDE, Stripes, Java, J2EE, EE, NetBeans RCP, JSF, Struts, Spring, Servlet API"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="book" lang="cs"><div><div><div><p class="university">MASARYKOVA UNIVERZITA</p><p class="faculty">FAKULTA INFORMATIKY</p><div class="facultylogo"><img src="fi-logo.png" alt="FAKULTA INFORMATIKY"></div><h1 class="title"><a name="id337600"></a>Podpora pro rámec Stripes v prost\v{r}edí NetBeans IDE</h1></div><div><h2 class="subtitle">Diplomová práce</h2></div><div><div class="author"><h3 class="author"><span class="firstname">Josef</span> <span class="surname">\v{S}ustá\v{c}ek</span></h3></div></div><div><p class="pubdate">Brno, jaro 2009</p><div class="declaration"><p class="title"><b>Prohlášení</b></p><p>Prohlašuji, že tato diplomová práce je mým původním autorským dílem, které jsem vypracoval samostatně. Všechny zdroje, prameny a literaturu, které jsem při vypracování používal nebo z nich čerpal, v práci řádně cituji s uvedením úplného odkazu na příslušný zdroj.</p></div><div class="advisor"><p class="title"><b>Vedoucí práce</b></p><p>Ing. Petr
      Adámek</p></div></div><div><div class="abstract"><p class="title"><b>Shrnutí</b></p><p>Tato diplomová práce se zabývá implementací webového rámce Stripes
      do prostředí NetBeans IDE a klade si za cíl zjednodušit tvorbu webových
      aplikací postavených na platformě Java.</p><p>NetBeans IDE je vývojové prostředí vycházející z platformy
      NetBeans, která je vysoce modulární a poskytuje tak podporu pro tvorbu
      nových zásuvných modulů. Celá platforma je šířena zdarma a včetně všech
      zdrojových kódů za podpory společnosti Sun.</p><p>Webový rámec Stripes je nadstavba nad Java Servlet API, která
      usnadňuje tvorbu webových aplikací. Je založen na principu architektury
      MVC a zajišťuje nejběžnější operace potřebné při tvorbě téměř každé
      webové aplikace. Mezi ně patří zpracování formulářů, validace vstupních
      hodnot, zobrazování zpráv uživatelům, řízení toku stránek a další. Rámec
      také obsahuje dobře použitelný systém šablon pro JSP stránky.</p><p>Propojením NetBeans IDE a Stripes vzniká silný nástroj, pomocí
      nějž lze v krátké době tvořit rozsáhlé, výkonné a přesto snadno
      udržovatelné aplikace založené na platformě Java.</p></div></div></div><hr></div><div class="toc"><p><b>Obsah</b></p><dl><dt><span class="chapter"><a href="#ch01">1. Úvod</a></span></dt><dt><span class="chapter"><a href="#j2ee">2. Vývoj webových aplikací v jazyce Java</a></span></dt><dd><dl><dt><span class="sect1"><a href="#id342858">Běhové prostředí -- kontejnery</a></span></dt><dt><span class="sect1"><a href="#webapps">Definice webové aplikace</a></span></dt><dd><dl><dt><span class="sect2"><a href="#pres_webapps">Prezentační webové aplikace</a></span></dt><dt><span class="sect2"><a href="#dd">Deployment deskriptor</a></span></dt></dl></dd><dt><span class="sect1"><a href="#servlets">Java Servlet API</a></span></dt><dd><dl><dt><span class="sect2"><a href="#http">Protokol HTTP</a></span></dt><dt><span class="sect2"><a href="#servlet">Servlet</a></span></dt><dt><span class="sect2"><a href="#id408443">Filtr</a></span></dt></dl></dd><dt><span class="sect1"><a href="#jsp">Java Server Pages</a></span></dt><dd><dl><dt><span class="sect2"><a href="#id408764">Srovnání přípustných formátů JSP</a></span></dt><dt><span class="sect2"><a href="#id408963">Standardní syntax JSP</a></span></dt></dl></dd><dt><span class="sect1"><a href="#id409986">Webové aplikační rámce</a></span></dt><dd><dl><dt><span class="sect2"><a href="#id340541">Typicky poskytované služby</a></span></dt><dt><span class="sect2"><a href="#mvc">Architektura MVC</a></span></dt><dt><span class="sect2"><a href="#id410872">Rámce založené na komponentách</a></span></dt><dt><span class="sect2"><a href="#id411781">Rámce založené na akcích</a></span></dt></dl></dd></dl></dd><dt><span class="chapter"><a href="#stripes">3. Rámec Stripes</a></span></dt><dd><dl><dt><span class="sect1"><a href="#id413013">Hlavní koncepty rámce Stripes</a></span></dt><dd><dl><dt><span class="sect2"><a href="#id413052">Action beans</a></span></dt><dt><span class="sect2"><a href="#obsluha_pozadavku">Obsluha požadavků</a></span></dt><dt><span class="sect2"><a href="#stripes_taglib">Knihovna značek Stripes</a></span></dt><dt><span class="sect2"><a href="#id415355">Možnosti tvorby šablon</a></span></dt></dl></dd><dt><span class="sect1"><a href="#id415513">Shrnutí konceptů a výhod užití</a></span></dt></dl></dd><dt><span class="chapter"><a href="#netbeans_RCP">4. NetBeans RCP</a></span></dt><dd><dl><dt><span class="sect1"><a href="#id415968">API použitá pro tvorbu nového modulu</a></span></dt><dd><dl><dt><span class="sect2"><a href="#id416004">Nodes API</a></span></dt><dt><span class="sect2"><a href="#id416100">Filesystems API, Datasystems API</a></span></dt><dt><span class="sect2"><a href="#id416282">Window System API</a></span></dt><dt><span class="sect2"><a href="#id416408">Web APIs, J2EE DD API</a></span></dt><dt><span class="sect2"><a href="#id416550">Project API, Project UI API, Java Project Support</a></span></dt><dt><span class="sect2"><a href="#lexer_api">Lexer API</a></span></dt><dt><span class="sect2"><a href="#id416826">Editor API, Text API</a></span></dt></dl></dd></dl></dd><dt><span class="chapter"><a href="#impl">5. Implementace zásuvného modulu</a></span></dt><dd><dl><dt><span class="sect1"><a href="#id417009">Implementovaná funkcionalita</a></span></dt><dd><dl><dt><span class="sect2"><a href="#id417054">Registrace rámce v projektu</a></span></dt><dt><span class="sect2"><a href="#new_templates">Nové šablony souborů</a></span></dt><dt><span class="sect2"><a href="#id409842">Nové položky JSP palety</a></span></dt><dt><span class="sect2"><a href="#new_features">Hypertextové odkazy</a></span></dt></dl></dd><dt><span class="sect1"><a href="#id418974">Použité nástroje a postupy</a></span></dt><dd><dl><dt><span class="sect2"><a href="#id418994">NetBeans IDE</a></span></dt><dt><span class="sect2"><a href="#id419137">Řízení projektu</a></span></dt><dt><span class="sect2"><a href="#id419408">Publikování nových verzí modulu</a></span></dt></dl></dd><dt><span class="sect1"><a href="#id419680">Problémy a jejich řešení</a></span></dt><dd><dl><dt><span class="sect2"><a href="#id419698">Dialogy pro výběr souboru</a></span></dt><dt><span class="sect2"><a href="#id419964">Refactoring</a></span></dt><dt><span class="sect2"><a href="#id420216">Přechod na platformu NetBeans verze 6.5</a></span></dt><dt><span class="sect2"><a href="#id420320">Testování</a></span></dt></dl></dd></dl></dd><dt><span class="chapter"><a href="#zaver">6. Závěr</a></span></dt><dt><span class="bibliography"><a href="#bib">Bibliografie</a></span></dt><dt><span class="index"><a href="#id422218">Rejstřík</a></span></dt></dl></div><div class="list-of-figures"><p><b>Seznam obrázků</b></p><dl><dt>2.1. <a href="#pic_webapps">Druhy webových aplikací</a></dt><dt>2.2. <a href="#pic_MVC">Koncept architektury MVC</a></dt><dt>3.1. <a href="#pic_dropdown">Drop-down menu</a></dt><dt>5.1. <a href="#pic_config_dialog">Konfigurační dialog</a></dt><dt>5.2. <a href="#pic_stripes_templete_usage_wizard">Průvodce vytvořením JSP obsahující využití šablony
          rozložení</a></dt><dt>5.3. <a href="#pic_action_bean_wizard">Průvodce vytvořením nové <span class="emphasis"><em>action bean</em></span>
          instance</a></dt><dt>5.4. <a href="#pic_palette">Paleta s položkami pro rámec Stripes</a></dt><dt>5.5. <a href="#pic_java_hyperlinks">Ukázka aktivních odkazů v jazyce Java</a></dt><dt>5.6. <a href="#pic_hyperlink_from_jsp">Aktivní odkaz vedoucí z JSP na <span class="emphasis"><em>action
          bean</em></span> instanci</a></dt><dt>5.7. <a href="#pic_hyperlink_from_bean">Aktivní odkaz směřující z action bean instance na danou JSP
          stránku</a></dt><dt>5.8. <a href="#pic_go_to_type">Návrh budoucího vzhledu dialogu pro výběr souboru
          Java</a></dt></dl></div><div class="chapter" lang="cs"><div class="titlepage"><div><div><h2 class="title"><a name="ch01"></a>Kapitola 1. Úvod</h2></div></div></div><p>Tvorba webových aplikací se stala v posledních letech jedním z
    nejrychleji se rozvíjejících odvětví vývoje softwaru. Již nestačí tvořit
    aplikace pro izolované uživatele, čím dál častěji je požadována komplexní
    funkcionalita založená především na spolupráci mnoha uživatelů, sdílení
    dat, autorizaci, autentizaci a dalších pokročilých funkcích. K naplnění
    těchto požadavků postupně vykrystalizovala specifická kategorie softwaru
    -- webové aplikace.</p><p>Tento druh aplikací lze tvořit v mnoha programovacích či
    skriptovacích jazycích, z nejpoužívanějších v současné době jmenujme C#,
    Javu, Ruby, Python či PHP. Každý z těchto jazyků má svoje specifika,
    výhody i nevýhody, mnoho expertů se však shoduje na tom, že pro opravdu
    robustní, škálovatelné, spolehlivé a výkonné aplikace je vhodné zvolit
    jazyk Java.</p><p>Tato volba v sobě v prvotním kroku zahrnuje zvýšené náklady, a to
    jak materiální, tak co se vzdělání týče. V současné době, na rozdíl od PHP
    či Ruby, stále neexistuje téměř žádný bezplatný hosting pro Java aplikace.
    A pokud už se nějaký najde, pak je poskytována pouze velmi omezená
    konfigurace, na které není možné provozovat žádný sofistikovanější systém
    používající některé z moderních prvků edice Java EE. Jedinou možností je
    placená služba nějakého zkušeného poskytovatele či vlastní server.</p><p>Základním nástrojem pro obsluhu komunikace přes protokol HTTP jsou
    standardy Java Servlet API a Java Server Pages. Jde o nízkoúrovňové
    řešení, s nímž lze sice vytvořit libovolnou aplikaci, ale je to zdlouhavé
    a neefektivní. Postupně tak začaly vznikat nadstavby nad těmito API, které
    vývoj webových aplikací v jazyce Java podstatně usnadňují -- webové
    rámce.</p><p>K maximální efektivitě využití možností, které rámce nabízejí, je
    velmi vhodné, aby pro ně byla co nejširší podpora ze strany vývojových
    prostředí jako jsou NetBeans, Eclipse či IDEA.</p><p>V kapitole <a href="#j2ee" title="Kapitola 2. Vývoj webových aplikací v jazyce Java">2 – „<i>Vývoj webových aplikací v jazyce Java</i>“</a> se nejprve seznámíme se specifiky
    vývoje webových aplikací v prostředí Java. V další kapitole <a href="#stripes" title="Kapitola 3. Rámec Stripes">3 – „<i>Rámec Stripes</i>“</a> podrobněji probereme architekturu rámce Stripes a
    srovnáme ho s dalšími používanými rámci. Náplň kapitoly <a href="#netbeans_RCP" title="Kapitola 4. NetBeans RCP">4 – „<i>NetBeans RCP</i>“</a> bude tvořit rozebrání návrhu platformy NetBeans
    a základní seznámení s API použitými k vývoji zásuvného modulu pro podporu
    rámce Stripes. Poté se již budeme v kapitole <a href="#impl" title="Kapitola 5. Implementace zásuvného modulu">5 – „<i>Implementace zásuvného modulu</i>“</a>
    zabývat samotným zásuvným modulem -- jeho možnostmi a implementací.
    Poslední kapitola <a href="#zaver" title="Kapitola 6. Závěr">6 – „<i>Závěr</i>“</a> rekapituluje a hodnotí dosažené
    výsledky a specifikuje prostor pro další rozvoj modulu.</p></div><div class="chapter" lang="cs"><div class="titlepage"><div><div><h2 class="title"><a name="j2ee"></a>Kapitola 2. Vývoj webových aplikací v jazyce Java</h2></div></div></div><p>Tato diplomová práce se zabývá integrací webového rámce do
    vývojového prostředí NetBeans, nejprve si tedy musíme objasnit, jak jsou
    webové aplikace v Javě specifikované a na jakých základech je každá taková
    webová aplikace vystavěna. K tomu je nezbytné ale nejdříve definovat
    prostředí, kde může každá webová aplikace běžet, a služby, které může
    využívat.</p><div class="sect1" lang="cs"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="id342858"></a>Běhové prostředí -- kontejnery</h2></div></div></div><p>Základní běhové prostředí pro webové aplikace v Javě poskytuje
      tzv. <span class="emphasis"><em>kontejner</em></span><a class="indexterm" name="id342869"></a>. Tato softwarová komponenta zajišťuje pro webové aplikace
      základní služby, například <span class="emphasis"><em>bezpečnost</em></span>,
      <span class="emphasis"><em>souběžnost</em></span>, <span class="emphasis"><em>řízení životního
      cyklu</em></span>, <span class="emphasis"><em>transakce</em></span> či <span class="emphasis"><em>nasazování
      nových webových aplikací</em></span>.</p><p>Podle typu komponent, které je možné v kontejneru nasadit a
      používat, jsou dále rozlišovány například <span class="emphasis"><em>Servlet
      kontejnery</em></span><span class="emphasis"><em>, EJB kontejnery</em></span> či
      <span class="emphasis"><em>Portlet kontejnery</em></span>. Nejpoužívanějšími jsou v
      současné době open-source kontejnery <span class="emphasis"><em>Apache Tomcat</em></span>,
      <span class="emphasis"><em>Liferay</em></span>, <span class="emphasis"><em>Jetty</em></span>,
      <span class="emphasis"><em>GlassFish</em></span> či komerční <span class="emphasis"><em>JBoss</em></span>
      nebo <span class="emphasis"><em>WebSphere</em></span> od IBM. Každý z nich zajišťuje
      nějakou podmnožinu popsaných služeb.</p></div><div class="sect1" lang="cs"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="webapps"></a>Definice webové aplikace</h2></div></div></div><p>Spolu s vydáním první verze <span class="emphasis"><em>Java Servlet
      API</em></span><sup>[<a href="#ftn.fn_JSAPI">1</a>]</sup> byl do jazyka Java,
      potažmo její edice J2EE, zaveden koncept <span class="emphasis"><em>webové
      aplikace</em></span><a class="indexterm" name="id342964"></a>. Podle této specifikace je webová aplikace definována
      takto: „<span class="quote">Webová aplikace je kolekcí servletů, HTML stránek, tříd a
      dalších zdrojů, které jsou společně svázány a lze je nasadit a používat
      na různých kontejnerech od různých výrobců.</span>“<a class="indexterm" name="id342980"></a> V zásadě lze rozlišit dva typy webových
      aplikací:<sup>[<a name="fn_JSAPI" href="#ftn.fn_JSAPI">1</a>]</sup></p><div class="itemizedlist"><ul type="disc"><li><p><span class="emphasis"><em>Prezentační webové aplikace</em></span><a class="indexterm" name="id343113"></a> -- tyto aplikace generují pro každého uživatele sadu
          dynamických webových stránek různého značkování (HTML, XHTML,
          XML...), které podle akcí prováděných uživatelem mění svůj obsah.
          Tyto aplikace často slouží jako klient -- neobsahují téměř žádnou
          aplikační logiku ani přímé spojení s perzistentním úložištěm
          (databází). Pokud prezentační aplikace potřebuje tyto služby využít,
          použije servisní třídy příslušné <span class="emphasis"><em>servisní</em></span>
          webové aplikace.</p></li><li><p><span class="emphasis"><em>Servisní webové aplikace</em></span><a class="indexterm" name="id343153"></a> -- slouží jako koncový bod, zajišťují zmíněné služby
          jako je persistence objektů a obsahují třídy reprezentující
          aplikační logiku. S prezentační částí komunikují nejrůznějšími
          způsoby. Pokud se nacházejí obě aplikace na různých strojích, je
          třeba využít některou z metod vzdálené komunikace -- například
          pomocí <span class="emphasis"><em>webových služeb</em></span> nebo některého z
          <span class="emphasis"><em>RPC protokolů</em></span> (<span class="emphasis"><em>Remote Procedure
          Call</em></span>). Často je však servisní aplikace přibalena k
          prezentační formou knihovny a všechna komunikace je redukována na
          volání jednotlivých metod servisních tříd.</p></li></ul></div><p>Celou situaci ilustruje schématický obrázek <a href="#pic_webapps" title="Obrázek 2.1. Druhy webových aplikací">2.1 – „Druhy webových aplikací“</a>. Tato idea dekompozice má velmi blízko k
      architektuře klient-server, více viz <a href="#bib_CS">CS</a>.</p><div class="figure"><a name="pic_webapps"></a><p class="title"><b>Obrázek 2.1. Druhy webových aplikací</b></p><div class="mediaobject"><table border="0" summary="manufactured viewport for HTML img" cellspacing="0" cellpadding="0" width="437"><tr><td><img src="images/webapps.png" width="437" alt="Druhy webových aplikací"></td></tr></table></div></div><div class="sect2" lang="cs"><div class="titlepage"><div><div><h3 class="title"><a name="pres_webapps"></a>Prezentační webové aplikace</h3></div></div></div><p>Nadále se již budeme zabývat pouze prezentačními webovými
        aplikacemi<a class="indexterm" name="id343261"></a>, jelikož webové rámce jako Stripes jsou součástí právě
        prezentačních vrstev. V dalším obsahu bude pojem <span class="emphasis"><em>webová
        aplikace</em></span> synonymem pro <span class="emphasis"><em>prezentační webovou
        aplikaci</em></span>.</p><p>Jedna z vlastností webových aplikací je vztah se
        <span class="emphasis"><em>Servletovým kontextem</em></span>. Každá webová aplikace má
        právě jeden takový kontext. Vztah mezi kontextem a webovou aplikací je
        kontrolován kontejnerem a tento zajišťuje, že každé dvě aplikace
        nasazené v témže kontejneru mezi sebou nebudou nijak kolidovat ani se
        navzájem ovlivňovat.</p><p>Součástí webové aplikace mohou být tyto objekty:</p><div class="itemizedlist"><ul type="disc"><li><p>servlety;</p></li><li><p>JSP soubory;</p></li><li><p>třídy implementované v jazyce Java;</p></li><li><p>statické dokumenty -- HTML soubory, obrázky a další;</p></li><li><p>meta informace sloužící k popisu dané webové
            aplikace.</p></li></ul></div><p><a name="web_app_example"></a>Každá webová aplikace má podle specifikace
        přesně danou souborovou strukturu, která je vyžadovaná každým
        kontejnerem. Webová aplikace s nesprávnou strukturou buď nepůjde do
        kontejneru ani nasadit, nebo nebude správně pracovat.</p><p>Pro ukázku zvolme jako kořen naší aplikace složku
        <span class="emphasis"><em>ovoceAZelenina</em></span><a class="indexterm" name="id341304"></a>. Pak správně strukturovaná webová aplikace bude vypadat
        následovně:</p><div class="itemizedlist"><ul type="disc"><li><p><span class="emphasis"><em>/ovoceAZelenina</em></span></p><p>Tato složka (a případně i všechny její podsložky) obsahují
            soubory, které budou po nasazení v kontejneru přímo adresovatelné
            pomocí URL. Soubor:</p><p><span class="emphasis"><em>/ovoceAZelenina/dalsi/zeli.html</em></span></p><p>bude typicky dostupný na adrese:</p><p><span class="emphasis"><em>http://&lt;nase_domena&gt;:&lt;port_kontejneru&gt;/ovoceAZelenina/dalsi/zeli.html</em></span>.</p></li><li><p><span class="emphasis"><em>/ovoceAZelenina/WEB-INF</em></span></p><p>Obsahem této složky jsou nejčastěji různé <span class="emphasis"><em>XML
            deskriptory</em></span> dané webové aplikace (například
            <span class="emphasis"><em>web.xml</em></span>, viz podkapitola <a href="#dd" title="Deployment deskriptor">„Deployment deskriptor“</a>), mohou se zde ale nacházet i libovolné další
            zdroje stejně jako v kořenové složce. Žádný z obsažených souborů
            není ale přímo dostupný pomocí své URL.</p></li><li><p><span class="emphasis"><em>/ovoceAZelenina/WEB-INF/lib</em></span></p><p>V této složce jsou všechny <span class="emphasis"><em>jar</em></span> soubory
            naší webové aplikace -- knihovny, na kterých je naše aplikace
            závislá. Například knihovna pro <span class="emphasis"><em>tvorbu log
            souborů</em></span>, vzdálený přístup k jiným aplikacím a budou se
            zde nacházet i knihovny potřebné k běhu rámce
            <span class="emphasis"><em>Stripes</em></span>, pokud ho budeme chtít v naší webové
            aplikaci využívat.</p></li><li><p><span class="emphasis"><em>/ovoceAZelenina/WEB-INF/classes</em></span></p><p>Složka obsahující zkompilované třídy naší aplikace --
            například servlety, viz podkapitola <a href="#servlets" title="Java Servlet API">„Java Servlet API“</a>.</p></li></ul></div></div><div class="sect2" lang="cs"><div class="titlepage"><div><div><h3 class="title"><a name="dd"></a>Deployment deskriptor</h3></div></div></div><p>Srdcem každé webové aplikace je její <span class="emphasis"><em>deployment
        deskriptor</em></span><a class="indexterm" name="id341798"></a>. Je reprezentován XML souborem
        <span class="emphasis"><em>web.xml</em></span><a class="indexterm" name="id341812"></a>, který je umístěn ve složce
        <span class="emphasis"><em>WEB-INF</em></span>, v našem příkladu půjde tedy konkrétně o
        soubor <span class="emphasis"><em>ovoceAZelenina/WEB-INF/web.xml</em></span>. Tento XML
        soubor popisuje nastavení pro celou webovou aplikaci. Obsahuje
        například tyto elementy:</p><div class="itemizedlist"><ul type="disc"><li><p><span class="emphasis"><em>inicializační parametry</em></span> servletového
            kontextu;</p></li><li><p><span class="emphasis"><em>konfiguraci sezení</em></span>
            (<span class="emphasis"><em>session</em></span>) -- jak dlouho bude například trvat,
            než vyprší;</p></li><li><p><span class="emphasis"><em>definice servletů a filtrů</em></span>;</p></li><li><p><span class="emphasis"><em>mapování servletů a filtrů na URL</em></span> --
            lze využít i divoké karty, například servlet mapovaný na URL
            <span class="emphasis"><em>*.action</em></span> bude obsluhovat všechny URL končící
            na <span class="emphasis"><em>.action</em></span>;</p></li><li><p><span class="emphasis"><em>mapování MIME typů</em></span>;</p></li><li><p><span class="emphasis"><em>seznam výchozích souborů</em></span> -- ty budou ve
            složce vždy hledány, pokud není v URL explicitně zadán požadovaný
            soubor, typicky je proveden pokus o nalezení a zobrazení souboru
            <span class="emphasis"><em>index.html</em></span>;</p></li><li><p><span class="emphasis"><em>definici chybových stránek</em></span>, které budou
            zobrazeny pro dané chybové kódy HTTP protokolu -- například chyba
            s kódem 404, stránka s daným URL nebyla nalezena;</p></li><li><p><span class="emphasis"><em>ošetření bezpečnosti</em></span> -- které oblasti
            webové aplikace budou autentizované, jaké uživatelské role budou
            pro vstup požadovány apod.</p></li></ul></div><p>Pro názornost následuje jednoduchý příklad deployment
        deskriptoru, který do webové aplikace přidává podporu pro rámec
        Stripes:</p><a name="dd_example"></a><pre class="programlisting">&lt;?xml version="1.0" encoding="UTF-8"?&gt;
&lt;web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee" 
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee 
       http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"&gt;
    
    &lt;filter&gt;
        &lt;filter-name&gt;StripesFilter&lt;/filter-name&gt;
        &lt;filter-class&gt;net.sourceforge.stripes.
             controller.StripesFilter&lt;/filter-class&gt;
        &lt;init-param&gt;
            &lt;param-name&gt;LocalePicker.Locales&lt;/param-name&gt;
            &lt;param-value&gt;en:utf-8,cs:utf-8&lt;/param-value&gt;
        &lt;/init-param&gt;
        &lt;init-param&gt;
            &lt;param-name&gt;ActionResolver.Packages&lt;/param-name&gt;
            &lt;param-value&gt;com.my.web.bean&lt;/param-value&gt;
        &lt;/init-param&gt;
    &lt;/filter&gt;
    &lt;filter-mapping&gt;
        &lt;filter-name&gt;StripesFilter&lt;/filter-name&gt;
        &lt;url-pattern&gt;*.jsp&lt;/url-pattern&gt;
        &lt;dispatcher&gt;REQUEST&lt;/dispatcher&gt;
    &lt;/filter-mapping&gt;
    &lt;filter-mapping&gt;
        &lt;filter-name&gt;StripesFilter&lt;/filter-name&gt;
        &lt;servlet-name&gt;DispatcherServlet&lt;/servlet-name&gt;
        &lt;dispatcher&gt;REQUEST&lt;/dispatcher&gt;
    &lt;/filter-mapping&gt;
    
    &lt;servlet&gt;
        &lt;servlet-name&gt;DispatcherServlet&lt;/servlet-name&gt;
        &lt;servlet-class&gt;net.sourceforge.stripes.
            controller.DispatcherServlet&lt;/servlet-class&gt;
        &lt;load-on-startup&gt;1&lt;/load-on-startup&gt;
    &lt;/servlet&gt;
    &lt;servlet-mapping&gt;
        &lt;servlet-name&gt;DispatcherServlet&lt;/servlet-name&gt;
        &lt;url-pattern&gt;*.action&lt;/url-pattern&gt;
    &lt;/servlet-mapping&gt;
    
    &lt;session-config&gt;
        &lt;session-timeout&gt;
            30
        &lt;/session-timeout&gt;
    &lt;/session-config&gt;
    &lt;welcome-file-list&gt;
        &lt;welcome-file&gt;index.jsp&lt;/welcome-file&gt;
    &lt;/welcome-file-list&gt;
&lt;/web-app&gt;</pre><p>V příkladu můžeme vidět, že se jedná o aplikaci užívající
        <span class="emphasis"><em>Java Servlet API</em></span> verze 2.5
        (<code class="classname">...&lt;web-app version="2.5"...</code>). Je definován
        pouze jeden HTTP filtr nesoucí název
        <code class="classname">StripesFilter</code>, který má dva inicializační
        parametry. Tento filtr je aplikován na všechny JSP stránky (URL
        končící na sekvenci <span class="emphasis"><em>.jsp</em></span>). Také je specifikován
        jeden servlet s názvem <code class="classname">DispatcherServlet</code>, který
        obsluhuje všechny URL ukončené sekvencí znaků
        <span class="emphasis"><em>.action</em></span>. Dále je nakonfigurováno sezení tak, že
        vyprší vždy za 30 minut. Posledním elementem je definice souborů,
        které se hledají ve složce, pokud nebyly v URL explicitně
        zvoleny.</p><p>Detailněji se budeme funkci a významu jednotlivých komponent,
        důležitých pro běh rámce Stripes, věnovat v kapitole <a href="#stripes" title="Kapitola 3. Rámec Stripes">3 – „<i>Rámec Stripes</i>“</a>.</p><p>Mnohé společnosti vyvíjející jednotlivé kontejnery podporují i
        řadu dalších deskriptorů pro webové aplikace, které se rovněž vždy
        nalézají ve složce <span class="emphasis"><em>WEB-INF</em></span>. Tyto vždy nějakým
        dalším způsobem rozšiřují možnosti konfigurace dané webové aplikace v
        oblasti, kterou neobsahuje specifikace <span class="emphasis"><em>Servlet
        API</em></span>. Příkladem může být soubor
        <span class="emphasis"><em>sun-web.xml</em></span>, který čte a aplikuje při nasazování
        aplikace pouze kontejner <span class="emphasis"><em>GlassFish</em></span> od firmy
        <span class="emphasis"><em>Sun</em></span> spolu se standardním deskriptorem
        <span class="emphasis"><em>web.xml</em></span>.</p></div></div><div class="sect1" lang="cs"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="servlets"></a>Java Servlet API</h2></div></div></div><p>Java Servlet API<a class="indexterm" name="id407738"></a> je základní normou pro zpracovávání HTTP požadavků v
      prostředí platformy Java. Tato specifikace vznikala od roku 1997 a
      postupně byla publikována jako jednotlivé normy
      <span class="emphasis"><em>JSR</em></span><sup>[<a href="#ftn.fn_jsr">2</a>]</sup>. K dnešnímu
      datu (10. březen 2009) je aktuální Servlet API verze 2.5 ze září roku
      2005 jako JSR 154. V poslední fázi připomínkového řízení je od ledna
      roku 2009 verze 3.0 jako JSR 315. Součástí edice J2EE jazyka Java se
      staly servlety od verze 2.2 (J2EE verze 1.2).<sup>[<a name="fn_jsr" href="#ftn.fn_jsr">2</a>]</sup></p><p>Při běžném provozu webových aplikací se téměř výhradně užívá
      protokol HTTP, případně jeho zabezpečená varianta HTTPS. Specifikace
      Java Servlet API obsahuje předem implementované třídy právě pro tento
      protokol, je však možné specifikaci využít i pro obsluhu dalších
      protokolů využívaných v internetovém prostředí.</p><p>Specifikace obsahuje popis dvou základních entit -- servletů a
      filtrů.</p><div class="sect2" lang="cs"><div class="titlepage"><div><div><h3 class="title"><a name="http"></a>Protokol HTTP</h3></div></div></div><p>Protokol HTTP<a class="indexterm" name="id407830"></a><a class="indexterm" name="id407839"></a> je nejběžnějším prostředkem pro získání obsahu z
        webového serveru prostřednictvím internetu. Pracuje na principu
        požadavek -- odpověď a je bezstavový. Mezi jednotlivými dotazy si
        server například nepamatuje údaje o uživateli, každý požadavek je
        nezávislý na každém dalším, i kdyby přišel ze stejného prohlížeče a od
        stejného uživatele. Pokud je držení stavu žádoucí, využívá se
        například <span class="emphasis"><em>sezení</em></span> nebo
        <span class="emphasis"><em>cookies</em></span>. První metoda je implementována na straně
        serveru, o druhou se stará klient (webový prohlížeč).</p><p>Typický životní cyklus jednoho požadavku lze ve zkratce popsat
        následující sekvencí. Klient (webový prohlížeč) pošle požadavek
        (<span class="emphasis"><em>request</em></span>) vytvořený pro danou URL zadanou
        uživatelem. K požadavku je případně v jeho těle připojen i obsah
        formuláře vyplněného uživatelem. Pokud je server nalezen, pro daný
        požadavek vrátí odpověď (<span class="emphasis"><em>response</em></span>), která
        nejčastěji obsahuje v těle HTML či XML značkování. Tento navrácený
        obsah webový prohlížeč zpracuje a graficky (případně textově) zobrazí
        uživateli.</p><p>Protokol definuje několik <span class="emphasis"><em>dotazovacích
        metod</em></span> -- možných druhů požadavků. Mezi nejvyužívanější
        metody patří tyto:</p><div class="itemizedlist"><ul type="disc"><li><p><span class="emphasis"><em>get</em></span> -- celý požadavek je určen pomocí
            URL požadované k zobrazení, případné parametry jsou součástí jako
            soubor dvojic klíč = hodnota.</p></li><li><p><span class="emphasis"><em>post</em></span> -- pomocí této metody se na server
            nejčastěji odesílají data většího objemu. Používá se například po
            vyplnění formuláře a odesílání jeho obsahu na server ke
            zpracování. Data se posílají v těle požadavku.</p></li><li><p><span class="emphasis"><em>options</em></span> -- slouží ke zjištění HTTP
            metod podporovaných daným serverem.</p></li></ul></div><p>Podrobnější informace o tomto komunikačním protokolu a kompletní
        popis všech jeho metod lze nalézt například na webu <a href="#bib_HTTP">HTTP</a>.</p></div><div class="sect2" lang="cs"><div class="titlepage"><div><div><h3 class="title"><a name="servlet"></a>Servlet</h3></div></div></div><p>Základním nástrojem pro obsluhu HTTP komunikace v Javě je
        <span class="emphasis"><em>servlet</em></span><a class="indexterm" name="id407986"></a>. Specifikace Java Servlet API je obecná a neomezuje se
        pouze na protokol HTTP, využít ji lze pro obsluhu libovolného
        protokolu založeného na principu požadavek -- odpověď.</p><p>V balíku <code class="classname">javax.servlet</code> se nachází
        rozhraní <code class="classname">Servlet</code> a jeho abstraktní implementace
        <code class="classname">GenericServlet</code>. K obsluze HTTP požadavků je k
        dispozici třída <code class="classname">HttpServlet</code> z balíku
        <code class="classname">javax.servlet.http</code>, která je rozšířením třídy
        <code class="classname">GenericServlet</code>. Rozhraní
        <code class="classname">Servlet</code> obsahuje především tyto tři
        metody:</p><div class="itemizedlist"><ul type="disc"><li><p><span class="emphasis"><em>init();</em></span></p></li><li><p><span class="emphasis"><em>service();</em></span></p></li><li><p><span class="emphasis"><em>destroy()</em></span>.</p></li></ul></div><p>Třída <code class="classname">HttpServlet</code> již obsahuje metody pro
        obsluhu jednotlivých druhů HTTP požadavků -- metod zmíněných v
        předešlé podkapitole <a href="#http" title="Protokol HTTP">„Protokol HTTP“</a>:</p><div class="itemizedlist"><ul type="disc"><li><p><span class="emphasis"><em>doGet()</em></span> -- obsluha HTTP požadavků
            generovaných metodou <span class="emphasis"><em>get;</em></span></p></li><li><p><span class="emphasis"><em>doPost()</em></span> -- obsluha HTTP požadavků
            odeslaných pomocí metody <span class="emphasis"><em>post</em></span> atd.</p></li></ul></div><div class="sect3" lang="cs"><div class="titlepage"><div><div><h4 class="title"><a name="id408122"></a>Životní cyklus servletu</h4></div></div></div><p>Typický životní cyklus<a class="indexterm" name="id408132"></a> každého servletu se dá popsat těmito čtyřmi
          body:</p><div class="orderedlist"><ol type="1"><li><p>Třída servletu je načtena do paměti příslušnou
              <span class="emphasis"><em>ClassLoader</em></span> instancí<sup>[<a href="#ftn.fn_classloader">3</a>]</sup>, která obsluhuje daný servletový
              kontejner.<sup>[<a name="fn_classloader" href="#ftn.fn_classloader">3</a>]</sup></p></li><li><p>Kontejner zavolá metodu <span class="emphasis"><em>init()</em></span>, dříve
              než je k servletu doručen první požadavek. Tato metoda je vždy
              zavolána právě jednou.</p></li><li><p>Servlet je připraven k provozu, kontejner volá metodu
              <span class="emphasis"><em>service()</em></span> pokaždé, když je HTTP požadavek
              určen pro tento servlet.</p></li><li><p>Nemá-li už být servlet nadále používán (webová aplikace,
              jejíž je součástí, je odinstalována z kontejneru apod.), zavolá
              kontejner metodu <span class="emphasis"><em>destroy()</em></span>, čímž končí
              životní cyklus tohoto servletu.</p></li></ol></div><p>V dalším textu, pokud nebude explicitně uvedeno jinak, budeme
          již pod pojmem <span class="emphasis"><em>servlet</em></span> mít vždy na mysli
          <span class="emphasis"><em>HTTP servlet</em></span>.</p></div><div class="sect3" lang="cs"><div class="titlepage"><div><div><h4 class="title"><a name="id408266"></a>Příklad servletu</h4></div></div></div><p>Každý servlet je potomkem třídy
          <code class="classname">HttpServlet</code> a musí překrývat vždy aspoň jednu
          z metod pro obsluhu HTTP požadavků. Tento servlet musí být rovněž
          korektně nadefinován v deskriptoru webové aplikace -- v souboru
          <span class="emphasis"><em>web.xml</em></span>. Příkladem jednoduchého servletu může
          být následující třída:</p><pre class="programlisting">package com.my.web.servlet;

import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
 
public class MyServlet extends HttpServlet {
    @Override
    public void doGet(HttpServletRequest req, HttpServletResponse res)
            throws ServletException, IOException {
        res.setContentType("text/html;charset=UTF-8");
        PrintWriter out = res.getWriter();

        try {
            out.println(
                "&lt;html&gt;\n" +
                "  &lt;head&gt;&lt;title&gt;My First Servlet&lt;/title&gt;&lt;/head&gt;\n" +
                "  &lt;body&gt;\n" +
                "    &lt;h1&gt;This is my first servlet ever made!&lt;/h1&gt;\n" +
                "  &lt;/body&gt;\n" + 
                "&lt;/html&gt;");
        } finally { 
            out.close();
        }
    }
}</pre><p>Správnou definice tohoto servletu v souboru
          <span class="emphasis"><em>web.xml</em></span> pak ilustruje tento fragment XML
          značkování:</p><pre class="programlisting">&lt;servlet&gt;
    &lt;servlet-name&gt;MyServlet&lt;/servlet-name&gt;
    &lt;servlet-class&gt;com.my.web.servlet.MyServlet&lt;/servlet-class&gt;
&lt;/servlet&gt;

&lt;servlet-mapping&gt;
    &lt;servlet-name&gt;MyServlet&lt;/servlet-name&gt;
    &lt;url-pattern&gt;/MyServletUrl&lt;/url-pattern&gt;
&lt;/servlet-mapping&gt;</pre><p>Servlet je podle definice určen na obsluhu jediné URL. Pokud
          by byl součástí naší demonstrační webové aplikace (viz podkapitola
          <a href="#pres_webapps" title="Prezentační webové aplikace">„Prezentační webové aplikace“</a>), byla by metoda
          <span class="emphasis"><em>doGet()</em></span> zavolána vždy, když by webový prohlížeč
          odeslal požadavek pomocí metody <span class="emphasis"><em>get</em></span> protokolu
          HTTP na URL
          <span class="emphasis"><em>&lt;nase_domena&gt;:&lt;port_kontejneru&gt;/ovoceAZelenina/MyServletUrl</em></span>.</p><p>Servlety se užívají ke generování obsahu nejrůznějších
          formátů, nejčastěji jsou výstupem HTML či XML stránky, jako tomu je
          i v našem jednoduchém příkladu. Ke generování větších fragmentů
          zmíněných formátů je však vhodnější využít přesměrování požadavku na
          nějakou JSP stránku. Jejich princip bude popsán v následující
          podkapitole <a href="#jsp" title="Java Server Pages">„Java Server Pages“</a>.</p><p>Dalším velmi častým použitím servletů je zpřístupnění souborů
          (obrázků, PDF dokumentů a dalších), které nejsou statické či nejsou
          dostupné z kořene webové aplikace (viz příklad v podkapitole <a href="#pres_webapps" title="Prezentační webové aplikace">„Prezentační webové aplikace“</a>). Stačí specifikovat správný typ obsahu --
          MIME typ<sup>[<a href="#ftn.fn_MIME">4</a>]</sup> -- a do odpovědi (objektu
          typu <code class="classname">HttpServletResponse</code>) zapsat obsah daného
          souboru jako proud bytů.<sup>[<a name="fn_MIME" href="#ftn.fn_MIME">4</a>]</sup></p></div></div><div class="sect2" lang="cs"><div class="titlepage"><div><div><h3 class="title"><a name="id408443"></a>Filtr</h3></div></div></div><p>Verze 2.3 specifikace Java Servlet API zavedla do konceptu
        webových aplikací novou entitu -- <span class="emphasis"><em>filtr</em></span><a class="indexterm" name="id408458"></a>. Tato komponenta dynamicky zachytává jednotlivé HTTP
        požadavky směřující na webovou aplikaci a provádí nad nimi požadované
        operace. Filtry -- stejně jako servlety -- jsou mapovány na obsluhu
        URL podle definice v deployment deskriptoru (viz podkapitola <a href="#dd" title="Deployment deskriptor">„Deployment deskriptor“</a>).</p><p>Specifikace komponenty filtr je dána rozhraním
        <code class="classname">Filter</code> z balíku
        <code class="classname">javax.servlet</code>. Konkrétní filtr je pak třídou
        implementující toto rozhraní. Specifikace neobsahuje žádnou generickou
        implementaci filtru ani specifické rozhraní pro HTTP filtr. Rozhraní
        <code class="classname">Filter</code> obsahuje metodu:</p><pre class="programlisting">void doFilter(ServletRequest request, ServletResponse response, 
    FilterChain chain)</pre><p>Životní cyklus filtru je velmi podobný servletu, rozhraní
        <code class="classname">Filter</code> rovněž obsahuje metody
        <span class="emphasis"><em>init()</em></span> a <span class="emphasis"><em>destroy()</em></span> se
        sémantikou ekvivalentní metodám z rozhraní
        <code class="classname">Servlet</code>.</p><p>Filtry mohou plnit nejrůznější funkce, příklady možného využití
        lze nalézt v následujícím výčtu:</p><div class="itemizedlist"><ul type="disc"><li><p><span class="emphasis"><em>Autentizace</em></span> -- na základě údajů o
            přihlášeném uživateli (které lze získat z předaného
            <code class="classname">HttpServletRequest</code> objektu) je možné
            zamítnout přístup do určité oblasti webové aplikace. Požadavek je
            typicky filtrem přesměrován na stránku s chybovou zprávou.</p></li><li><p><span class="emphasis"><em>Tvorba log souborů a evidence užívání</em></span>
            -- filtry lze rovněž využít ke sledování návštěvnosti jednotlivých
            stránek, případně k zaznamenávání statistik o jednotlivých
            požadavcích apod.</p></li><li><p><span class="emphasis"><em>Transformace XML pomocí XSLT šablon</em></span> --
            podle typu zařízení, ze kterého byl odeslán požadavek, je možné
            přeformátovat XML výstup tak, aby maximálně vyhovoval danému
            zobrazovacímu zařízení.</p></li><li><p><span class="emphasis"><em>Komprese dat</em></span> -- pokud webový prohlížeč
            podporuje příjem HTTP odpovědí v komprimovaném formátu (GZIP
            apod.), je možné například původní odpověď servletu zkomprimovat a
            tím urychlit přenos odpovědi ze serveru zpět k webovému
            prohlížeči.</p></li><li><p><span class="emphasis"><em>Lokalizace</em></span> -- s využitím dat o
            uživateli, který požadavek vytvořil, lze požadavek nasměrovat na
            obsah s regionálním nastavením co nejvíce se blížícím jeho místním
            zvyklostem, například správným časovým pásmem, měnou a
            podobně.</p></li></ul></div><p>Jeden HTTP požadavek může projít i více filtry, pořadí jejich
        aplikace je dáno pořadím jejich deklarace v deployment deskriptoru.
        Filtr má zároveň možnost v metodě <span class="emphasis"><em>doFilter()</em></span>
        rozhodnout, že aktuální filtr bude posledním aplikovaným. Dalšími
        filtry tak na aktuální požadavek nebudou použity.</p><p>Více informací o filtrech a jejich využití, včetně příkladů, lze
        nalézt například v <a href="#bib_FLTR">FLTR</a>.</p></div></div><div class="sect1" lang="cs"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="jsp"></a>Java Server Pages</h2></div></div></div><p>Jak již bylo naznačeno v předešlé podkapitole <a href="#servlet" title="Servlet">„Servlet“</a>, servlety se příliš nehodí ke generování velkého
      objemu dat formátu HTML či XML. Snaha o účelnější způsob generovaní
      tohoto druhu dat vedla ke vzniku <span class="emphasis"><em>Java Server
      Pages</em></span><a class="indexterm" name="id408694"></a><a class="indexterm" name="id408703"></a>.</p><p>Počínaje verzí 1.2 technologie vycházela z <span class="emphasis"><em>Java
      Community Process</em></span> formou jednotlivých specifikací JSR. Java
      servlety a technologie JSP jsou velmi úzce provázané, jsou proto i často
      součástí jednoho JSR (Java Servlets 2.3 a JSP 1.2 jsou dány společnou
      normou JSR 53). JSP 2.0 je samostatnou normou pokrytou JSR 152, od
      května roku 2006 je v platnosti finální verze JSR 245, jejíž součástí je
      specifikace JSP verze 2.1. V dalším textu se budeme zabývat vlastnostmi
      JSP podle nejnovější specifikace (2.1), pokud nebude výslovně zmíněna
      jiná verze.</p><p>Pokud do kontejneru přijde požadavek na zobrazení výstupu nějaké
      JSP stránky, je nejprve zvolená stránka převedena na servlet pomocí JSP
      kompilátoru. Ten generuje buď Java byte kód, nebo zdrojový kód v jazyce
      Java, který je posléze přeložen běžným překladačem jazyka Java.
      Jednotlivé servlety lze generovat až při příchodu požadavku vedoucího na
      danou JSP stránku, či je všechny vygenerovat předem. Toto chování
      kontejneru lze ovlivnit, pro každou webovou aplikaci existuje možnost
      explicitně povolit či zakázat automatické generování servletů z JSP
      stránek.</p><div class="sect2" lang="cs"><div class="titlepage"><div><div><h3 class="title"><a name="id408764"></a>Srovnání přípustných formátů JSP</h3></div></div></div><p>V zásadě jsou možné dvě syntaxe JSP souborů:
        <span class="emphasis"><em>standardní syntax</em></span> a <span class="emphasis"><em>XML
        syntax</em></span><a class="indexterm" name="id408783"></a>. Oba zápisy jsou stejně silné -- oběma lze dosáhnout
        stejného výstupu.</p><p>Rozdíl mezi nimi si demonstrujeme na jednoduchém příkladu. JSP
        stránka utvořená pomocí <span class="emphasis"><em>XML syntaxe</em></span> je čisté XML
        -- správně strukturované a validní. Jednoduchý soubor vzniklý tímto
        postupem může ilustrovat následující příklad:</p><pre class="programlisting">&lt;?xml version="1.0" encoding="UTF-8"?&gt;

&lt;jsp:root xmlns:jsp="http://java.sun.com/JSP/Page" version="2.0"&gt;

    &lt;jsp:directive.page contentType="text/html" pageEncoding="UTF-8"/&gt;

    &lt;!-- any content can be specified here, e.g.: --&gt;
    &lt;jsp:text&gt;
        &lt;html&gt;
            &lt;head&gt;
                &lt;meta http-equiv="Content-Type" 
                    content="text/html; charset=UTF-8" /&gt;
                &lt;title&gt;JSP Page&lt;/title&gt;
            &lt;/head&gt;
            &lt;body&gt;
                &lt;h1&gt;Hello &lt;i&gt;World&lt;/i&gt;!&lt;/h1&gt;
            &lt;/body&gt;
        &lt;/html&gt;
    &lt;/jsp:text&gt;
&lt;/jsp:root&gt;
</pre><p>Standardní JSP syntax vypadá při stejném výstupu takto:</p><pre class="programlisting">&lt;%@page contentType="text/html" pageEncoding="UTF-8"%&gt;

&lt;html&gt;
    &lt;head&gt;
        &lt;meta http-equiv="Content-Type" 
            content="text/html; charset=UTF-8" /&gt;
        &lt;title&gt;JSP Page&lt;/title&gt;
    &lt;/head&gt;
    &lt;body&gt;
        &lt;h1&gt;Hello &lt;i&gt;World&lt;/i&gt;!&lt;/h1&gt;
    &lt;/body&gt;
&lt;/html&gt;</pre><p>Druhý způsob zápisu -- standardní JSP syntax -- v drtivé většině
        webových aplikací převažuje nad prvním, a to z několika důvodů:</p><div class="itemizedlist"><ul type="disc"><li><p>je stručnější -- stránky pomocí ní lze tvořit
            rychleji;</p></li><li><p>je čitelnější -- neobsahuje „<span class="quote">upovídané</span>“ části
            bez viditelného výstupu;</p></li><li><p>je známější -- pro CSS designéry znalé (X)HTML je standardní
            syntax snazší na pochopení a přístupnější k vytvoření sedícího
            stylu;</p></li><li><p>umožňuje přímočarý HTML výstup -- HTML není kompatibilní s
            XML, nepárové značky by tak musely být při použití XML syntaxe
            uzavřeny v CDATA sekcích;</p></li><li><p>je stejně silná jako XML syntax.</p></li></ul></div><p>Z těchto důvodů se dále budeme zabývat pouze
        <span class="emphasis"><em>standardní syntaxí</em></span><sup>[<a href="#ftn.fn_jsp_xml_syntax">5</a>]</sup>.<sup>[<a name="fn_jsp_xml_syntax" href="#ftn.fn_jsp_xml_syntax">5</a>]</sup></p></div><div class="sect2" lang="cs"><div class="titlepage"><div><div><h3 class="title"><a name="id408963"></a>Standardní syntax JSP</h3></div></div></div><p>V každé JSP stránce<a class="indexterm" name="id408973"></a> můžeme rozlišit těchto pět základních částí (ne všechny
        ale musí být vždy využity):</p><div class="itemizedlist"><ul type="disc"><li><p><span class="emphasis"><em>statická data</em></span> -- například HTML
            značkování;</p></li><li><p><span class="emphasis"><em>JSP akce</em></span> -- nejčastěji užívány k
            vyvolání akcí v kontejneru;</p></li><li><p><span class="emphasis"><em>JSP direktivy</em></span> -- slouží například k
            vložení jiné stránky, viz dále;</p></li><li><p><span class="emphasis"><em>JSP skriplety</em></span> a výrazy
            <span class="emphasis"><em>Expression Language</em></span> -- bude rozebráno
            vzápětí;</p></li><li><p><span class="emphasis"><em>značky</em></span> z <span class="emphasis"><em>dalších</em></span>
            JSP <span class="emphasis"><em>knihoven</em></span> -- například
            <span class="emphasis"><em>JSTL</em></span>, jež bude blíže rozebrána později v této
            podkapitole.</p></li></ul></div><p>Použití statických dat je nejpřímočařejší, nejčastěji ho tvoří
        HTML či modernější XHTML značkování. Podrobnější informace o dalších
        částech JSP stránek jsou podány v následujících podkapitolách.</p><div class="sect3" lang="cs"><div class="titlepage"><div><div><h4 class="title"><a name="id409084"></a>JSP akce</h4></div></div></div><p>JSP akce jsou XML značky, které vždy vyvolají nějakou akci na
          straně kontejneru. Jsou vyvolávány vždy až za běhu servletu, do
          kterého byla daná JSP stránka přeložena. Nejpoužívanější
          jsou:</p><div class="itemizedlist"><ul type="disc"><li><p><span class="emphasis"><em>jsp:useBean</em></span> -- vytvoří Java Bean
              instanci dané třídy s daným ID, popřípadě znovu využije
              dostupnou instanci v aktuální stránce;</p></li><li><p><span class="emphasis"><em>jsp:include</em></span> -- chování je identické
              jako u <span class="emphasis"><em>direktivy include;</em></span></p></li><li><p><span class="emphasis"><em>jsp:getProperty </em></span> -- spolu s duální
              akci <span class="emphasis"><em>jsp:setProperty</em></span> získá, popřípadě
              zapíše hodnotu parametru v dané Java Bean instanci.</p></li></ul></div><p>Specifikace obsahuje i další akce, mimo jiné
          <span class="emphasis"><em>jsp:forward</em></span>, která přesměruje aktuální
          požadavek na jinou URL -- JSP stránku nebo servlet. Její užívání se
          ale příliš nedoporučuje, pokud se snaží programátor dodržet princip
          architektury <span class="emphasis"><em>Model-View-Controller</em></span> --
          <span class="emphasis"><em>MVC</em></span>. V této totiž JSP stránky slouží pouze jako
          komponenta zobrazující data uživateli (<span class="emphasis"><em>View</em></span>) a
          zásadně neprovádí žádná přesměrování či podobné akce. Princip MVC
          přístupu k budování aplikací bude podrobněji probrán v podkapitole
          <a href="#mvc" title="Architektura MVC">„Architektura MVC“</a>.</p></div><div class="sect3" lang="cs"><div class="titlepage"><div><div><h4 class="title"><a name="id409188"></a>JSP direktivy</h4></div></div></div><p>JSP direktivy jsou uzavřeny v sekvenci znaků <code class="classname">&lt;%@
          %&gt;</code>, ve specifikaci jsou uvedeny tyto tři:</p><div class="itemizedlist"><ul type="disc"><li><p><span class="emphasis"><em>include</em></span> -- slouží ke vložení obsahu
              jiné JSP stránky do té aktuální:</p><pre class="programlisting">&lt;%@ include file="somefile.jspf" %&gt; </pre></li><li><p><span class="emphasis"><em>page</em></span> -- má mnoho použití, například
              nastavuje <span class="emphasis"><em>content-type</em></span> dané JSP stránky
              nebo její kódování:</p><pre class="programlisting">&lt;%@ page contentType="text/html" %&gt;
&lt;%@ page pageEncoding="UTF-8" %&gt; </pre></li><li><p><span class="emphasis"><em>taglib</em></span> -- slouží k rozšíření sady
              dostupných značek o značky definované nějakou knihovnou:</p><pre class="programlisting">&lt;%@ taglib prefix="s" 
    uri="http://stripes.sourceforge.net/stripes.tld" %&gt;</pre></li></ul></div></div><div class="sect3" lang="cs"><div class="titlepage"><div><div><h4 class="title"><a name="id409275"></a>Dynamický obsah JSP stránek</h4></div></div></div><p>Základním účelem JSP komponent je generování dynamického
          obsahu, dosáhnout toho lze buď psaním <span class="emphasis"><em>skripletů</em></span>
          nebo využíváním výrazů <span class="emphasis"><em>Expression
          language</em></span><a class="indexterm" name="id409297"></a>.</p><p>První způsob vychází ze starších verzí JSP a od jeho užívání
          je upouštěno, protože znepřehledňuje JSP kód a svádí ke špatným
          vzorcům programování. Od JSP verze 2.0 byl zaveden uniformní jazyk
          výrazů -- <span class="emphasis"><em>Expression language</em></span> (dále jen EL).
          Byla sjednocena jeho syntaxe s podobným jazykem užívaným v JSF
          komponentách (viz dále).</p><p>Ať se programátor rozhodne pro kterýkoliv přístup, vždy má v
          JSP stránce k dispozici sadu implicitních objektů. O jejich
          zpřístupnění a korektní zinicializování se stará kontejner
          spravující příslušnou JSP stránku. Mezi tyto objekty patří aktuální
          <span class="emphasis"><em>sezení</em></span> (<span class="emphasis"><em>session</em></span> --
          instance třídy implementující rozhraní
          <code class="classname">javax.servlet.http.HttpSession</code>), HTTP
          <span class="emphasis"><em>request</em></span> (instance implementující
          <code class="classname">javax.servlet.http.HttpServletRequest</code>) nebo
          odkaz na <span class="emphasis"><em>výstupní proud</em></span> určený k zápisu dat do
          HTTP odpovědi generované servletem (objekt typu
          <code class="classname">HttpServletResponse</code>).</p><p>Skriplety jsou části JSP kódu ohraničené sekvencí znaků
          <code class="classname">&lt;% %&gt;</code> a mohou obsahovat libovolný
          správně utvořený kus Java kódu. Tento kód je při překladu JSP
          stránky na servlet přímo vložen na dané místo do metody obsluhující
          HTTP požadavek.</p><p>Skriplet může být rovněž uzavřen znaky <code class="classname">&lt;%!
          %&gt;</code>, obsažený Java kód bude do výsledného servletu
          vložen mimo obslužnou metodu, lze v něm tedy například definovat
          novou metodu nebo atribut daného servletu.</p><p>V našem příkladu uvažme dvě třídy, <code class="classname">User</code>
          a <code class="classname">Book</code>, které jsou obě správně utvořené Java
          Beans<sup>[<a href="#ftn.fn_beans">6</a>]</sup>. JSP skriplet pak může
          vypadat třeba takto:<sup>[<a name="fn_beans" href="#ftn.fn_beans">6</a>]</sup></p><pre class="programlisting">User has specified a book with name 
&lt;% 
User user = (User) request.getAttribute("user");
    if (user != null) {
        Book book = user.getBook();
        if (book != null) {
            out.print(book.getName());
        }
    }
%&gt;.</pre><p>Oproti tomu, výrazy EL jsou celé uvozeny znakem
          <span class="emphasis"><em>dolar</em></span>(<span class="emphasis"><em>$</em></span>) a uzavřeny ve
          složených závorkách (<span class="emphasis"><em>{}</em></span>). Stejného výsledku
          jako v předešlém skripletu (tedy vypsání jména knihy daného
          uživatele) lze dosáhnout i použitím EL:</p><pre class="programlisting">User has specified a book with name ${user.book.name}.</pre><p>Úspora kódu je na první pohled zřejmá. Výrazy jazyka EL lze
          nyní využít v jakékoliv části dokumentu, výskyt není omezen pouze na
          atributy specifických značek, jak tomu bylo ve standardu JSP před
          verzí 2.0.</p><p>Výrazy EL mohou obsahovat proměnné základních primitivních
          typů známých z jazyka Java (<code class="classname">boolean</code>,
          <code class="classname">integer</code>, <code class="classname">float</code>,
          <code class="classname">string</code> a <code class="classname">null</code>),
          kolekce proměnných, stejně jako mapy (instance
          <code class="classname">java.util.Map</code>) a nad těmito mohou být dále
          prováděny jak aritmetické tak logické operace. Více o EL, jeho
          možnostech a omezeních lze najít například v <a href="#bib_EL">EL</a>.</p></div><div class="sect3" lang="cs"><div class="titlepage"><div><div><h4 class="title"><a name="taglibs"></a>Knihovny značek</h4></div></div></div><p>Expression language neobsahuje žádné konstrukce známé z
          imperativního paradigmatu, například <code class="classname">do-while</code>
          cyklus nebo <code class="classname">for</code> cyklus. Vhodným doplněním
          jazyka EL je tak některá <span class="emphasis"><em>knihovna
          značek</em></span><a class="indexterm" name="id409570"></a> pokrývající tyto požadavky, například
          <span class="emphasis"><em>JSTL</em></span> (<span class="emphasis"><em>Java Server Pages Standard Tag
          Library</em></span> )<a class="indexterm" name="id409595"></a>, produkt z portfolia společnosti Sun. Jde o kolekci
          pěti knihoven značek, námi požadované imperativní konstrukce
          obsahuje knihovna <span class="emphasis"><em>JSTL Core</em></span>. Ostatní knihovny
          slouží například pro práci s XML, SQL či k lokalizaci obsahu pomocí
          <span class="emphasis"><em>Java ResourceBundles</em></span><sup>[<a href="#ftn.fn_resource_bundle">7</a>]</sup>.<sup>[<a name="fn_resource_bundle" href="#ftn.fn_resource_bundle">7</a>]</sup></p><p>Knihovna se nejprve pomocí direktivy
          <span class="emphasis"><em>include</em></span> nadefinuje v hlavičce JSP stránky a pak
          již lze jí definované značky užívat v celém JSP dokumentu, vždy
          uvozené příslušným prefixem. Pokud tedy chceme projít kolekci
          (seznam či množinu) objektů, může kód využívající kombinaci JSTL a
          EL vypadat následovně (opět předpokládáme, že objekty v kolekci
          <code class="classname">users</code> jsou správně utvořené Java Beans s
          parametry <code class="classname">name</code> a
          <code class="classname">age</code>):</p><pre class="programlisting">&lt;%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %&gt;

There are following users available:

&lt;c:forEach var="user" items="${users}" &gt;
    ${user.name} - ${user.age}, 
&lt;/c:forEach&gt;</pre><p>Kompletní dokumentaci k JSTL lze nalézt v <a href="#bib_JSTL">JSTL</a>.</p><p>Pokud žádná existující knihovna značek nevyhovuje potřebám
          naší webové aplikace, lze si napsat i vlastní. Podrobných návodů lze
          nalézt na internetu dostatek, dobrým startovním bodem je například
          výukový kurz na webu firmy Sun, viz <a href="#bib_JSTLTUT">JSTLTUT</a> .</p></div></div></div><div class="sect1" lang="cs"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="id409986"></a>Webové aplikační rámce</h2></div></div></div><p>Spolu s uvedením dříve zmíněných specifikací, které dávají k
      dispozici základní nástroje k tvorbě webových aplikací v jazyce Java,
      začalo mnoho těchto aplikací vznikat. Postupem času začalo být zřejmé,
      že v jednotlivých webových aplikacích se často opakují podobné požadavky
      co se funkcionality týče. A to bylo hlavním impulsem ke vzniku prvních
      webových rámců<a class="indexterm" name="id410006"></a>.</p><p>Webové aplikační rámce jsou softwarové knihovny, které poskytují
      nástroje, jak typicky požadované <span class="emphasis"><em>služby</em></span> zpřístupnit
      pro libovolnou novou webovou aplikaci. Zabývat se budeme především
      službami týkajícími se tvorby uživatelského rozhraní, jelikož na tuto
      oblast je zaměřen i rámec Stripes.</p><p>Přehledný a poměrně obsáhlý seznam (obsahuje více jak 50 položek)
      existujících webových rámců dostupných pro jazyk Java lze nalézt v <a href="#bib_WFWRKS">WFWRKS</a>.</p><div class="sect2" lang="cs"><div class="titlepage"><div><div><h3 class="title"><a name="id340541"></a>Typicky poskytované služby</h3></div></div></div><p>Nejběžnější aspekty funkcionality<a class="indexterm" name="id340551"></a>, které poptává mnoho webových aplikací, shrnují
        následující podkapitoly.</p><div class="sect3" lang="cs"><div class="titlepage"><div><div><h4 class="title"><a name="id340570"></a>Autentizace a autorizace</h4></div></div></div><p>Webové aplikace velmi často vyžadují, aby svůj obsah
          generovaly v závislosti na uživateli, který k ní přistupuje. Tedy v
          první řadě je nutné zajistit správu uživatelských účtů a rolí,
          pomocí nichž je pak nejčastěji řízen systém oprávnění. Webové rámce
          přistupují k oběma úkolům různě. Některé jako jednotku přístupu
          používají JSP stránky -- daný uživatel ji buď může či nemůže
          zobrazit. Jiné využívají například Java anotací<sup>[<a href="#ftn.fn_anottations">8</a>]</sup> a autorizace je aplikována při
          vykonávání jednotlivých Java metod.<sup>[<a name="fn_anottations" href="#ftn.fn_anottations">8</a>]</sup></p></div><div class="sect3" lang="cs"><div class="titlepage"><div><div><h4 class="title"><a name="friendly_urls"></a>Tvorba hezkých URL</h4></div></div></div><p>V dnešní době je <span class="emphasis"><em>SEO</em></span> -- <span class="emphasis"><em>Search
          Engine Optimalization</em></span><sup>[<a href="#ftn.fn_SEO">9</a>]</sup> --
          velmi využívanou marketingovou metodou. Velkou devizou webové
          aplikace je tak její vstřícnost k internetovým vyhledávačům, jejíž
          součástí je i využívání dobře utvořených URL. Avšak URL generované
          webovou aplikací mohou být velmi dlouhé, nepřehledné a pro tyto
          účely zcela nepoužitelné. Mapování hezkých URL tak tvoří vhodný
          nástroj, jak na jedné straně ponechat vývojáři webové aplikace podle
          potřeby volnost v tvorbě URL a na druhé poskytnout celou aplikaci k
          dispozici vyhledávačům.<sup>[<a name="fn_SEO" href="#ftn.fn_SEO">9</a>]</sup></p></div><div class="sect3" lang="cs"><div class="titlepage"><div><div><h4 class="title"><a name="id410047"></a>Nástroje pro tvorbu šablon</h4></div></div></div><p>Pro návrh vzhledu webových stránek je jednou z dobrých technik
          <span class="emphasis"><em>dodržování jednotného vzhledu</em></span>. Tedy, že
          uživatel není při přechodu mezi jednotlivými stranami zmaten --
          navigaci například najde vždy na stejném místě, hlavní obsahové
          sdělení každé stránky je zřetelně označené, barevné schéma se
          radikálně nemění a je přiměřeně kontrastní apod. V rozsáhlých
          webových aplikacích se typicky zobrazuje mnoho různých dat. Obsah
          výsledné stránky pak z velké části tvoří stále stejný obsah --
          hlavička, menu, rychlá navigace či patička.</p><p>K dosažení jednotného vzhledu nabízí mnoho webových rámců
          <span class="emphasis"><em>systémy pro tvorbu šablon</em></span>, tedy možnost
          definovat různé vzory rozložení. Pro konkrétní obsah lze pak jen
          zvolit použití vybrané šablony a dodat konkrétní data zobrazená na
          stránce. Tím se docílí jak výše zmíněné jednotnosti vzhledu, tak i
          lepší udržovatelnosti zdrojových kódů.</p></div><div class="sect3" lang="cs"><div class="titlepage"><div><div><h4 class="title"><a name="id410099"></a>Cache</h4></div></div></div><p>Pro vytížené webové aplikace, které mají za úkol obsluhovat
          mnoho uživatelských požadavků současně, je téměř nezbytné využívat
          nějakou úroveň ukládání do vyrovnávací paměti
          (<span class="emphasis"><em>cache</em></span>). Pokud jsou splněny určité požadavky,
          pak dva různé požadavky na tutéž stránku mohou být uspokojeny
          stejným výsledkem s tím, že v druhém případě se již poskytne jako
          odpověď stránka vygenerovaná pro předešlý požadavek. Tím se
          například zamezí opakovanému přístupu do databáze pro stejná data či
          interpretaci šablony rozložení (viz předchozí bod).</p></div><div class="sect3" lang="cs"><div class="titlepage"><div><div><h4 class="title"><a name="id410132"></a>AJAX</h4></div></div></div><p><span class="emphasis"><em>Asynchronous JavaScript and XML</em></span> neboli
          <span class="emphasis"><em>AJAX</em></span> se postupně vyvinul jako reakce na
          požadavek, aby webové aplikace byly více interaktivní. Standardně
          fungují webové aplikace na principu požadavek-odpověď (podrobnosti
          viz podkapitola <a href="#http" title="Protokol HTTP">„Protokol HTTP“</a>). To však často vede ke
          zbytečnému přenosu stále stejného HTML značkování. Pokud výsledek
          akce směruje uživatele na stejnou stránku, ze které byl požadavek
          odeslán, často není třeba získávat kompletní HTML stránku. Stačí
          získat relevantní data, která se provedenou akcí změnila a tyto
          zakomponovat do současné HTML stránky.</p><p>Dalším velmi obvyklým příkladem užití může být
          <span class="emphasis"><em>našeptávač</em></span>. Ten při vyplňování textového pole
          ve formuláři dynamicky získává ze serveru relevantní data
          odpovídající již napsanému textu a dává je k dispozici uživateli
          jako přehledný seznam zobrazený pod textovým polem. Uživatel pak
          nemusí vypisovat celý obsah pole, stačí vybrat z nabízených hodnot,
          pokud mu některá vyhovuje.</p><p>V současné době již existuje mnoho knihoven napsaných v jazyce
          JavaScript, které asynchronní získávání dat redukují na záležitost
          několika řádků kódu. Z nejznámějších uveďme
          <span class="emphasis"><em>jQuery</em></span><sup>[<a href="#ftn.fn_ajax_libs">10</a>]</sup>,
          <span class="emphasis"><em>DOJO</em></span><sup>[<a href="#ftn.fn_ajax_libs">10</a>]</sup> nebo
          <span class="emphasis"><em>Prototype</em></span><sup>[<a href="#ftn.fn_ajax_libs">10</a>]</sup>. Tyto jsou často součástí samotných
          webových rámců a poskytují i nějakou pokročilejší míru
          integrace.<sup>[<a name="fn_ajax_libs" href="#ftn.fn_ajax_libs">10</a>]</sup></p></div><div class="sect3" lang="cs"><div class="titlepage"><div><div><h4 class="title"><a name="id410274"></a>Přístup do databáze</h4></div></div></div><p>Tento aspekt se do oblasti prezentačních webových rámců příliš
          počítat nedá. Většinou se užívá striktní oddělení prezentační vrstvy
          a aplikační logiky (viz obrázek <a href="#pic_webapps" title="Obrázek 2.1. Druhy webových aplikací">2.1 – „Druhy webových aplikací“</a>) a o
          přímý přístup do databáze se stará jiná část aplikace. Nicméně pro
          rychlou tvorbu prototypů obsahují i některé prezentační rámce
          možnosti přístupu do databáze, objektově-relační
          mapování<sup>[<a href="#ftn.fn_ORM">11</a>]</sup> nebo řízení
          transakcí.<sup>[<a name="fn_ORM" href="#ftn.fn_ORM">11</a>]</sup></p></div></div><div class="sect2" lang="cs"><div class="titlepage"><div><div><h3 class="title"><a name="mvc"></a>Architektura MVC</h3></div></div></div><p>Častým problémem rostoucích aplikací, nejen webových, se stává
        udržovatelnost produkovaného kódu. S časem se požadavky na aplikaci
        mohou měnit, a ta se jim musí přizpůsobovat. Proto je velmi důležité
        už na začátku návrhu zvolit vhodnou architekturu, nejlépe s využitím
        již vyzkoušených <span class="emphasis"><em>návrhových vzorů</em></span><sup>[<a href="#ftn.fn_design_patterns">12</a>]</sup>.<sup>[<a name="fn_design_patterns" href="#ftn.fn_design_patterns">12</a>]</sup></p><p>Téma návrhových vzorů a obecně architektura SW systémů by vydaly
        na samostatnou práci, my se budeme krátce zabývat pouze konceptem
        často využívaným v prezentačních webových rámcích. Tím je architektura
        <span class="emphasis"><em>MVC -- Model-View-Controller</em></span><a class="indexterm" name="id410418"></a>, jejíchž pravidel se drží i rámec Stripes. Nyní si
        tento způsob tvorby webových aplikací blíže popíšeme.</p><div class="sect3" lang="cs"><div class="titlepage"><div><div><h4 class="title"><a name="id410435"></a>Základní koncept</h4></div></div></div><p>Základním stavebním kamenem konceptu MVC je jasné oddělení
          následujících tří složek webové aplikace:</p><div class="itemizedlist"><ul type="disc"><li><p><span class="emphasis"><em>model</em></span> -- data z doménové oblasti,
              kterou aplikace pokrývá;</p></li><li><p><span class="emphasis"><em>view</em></span> -- vizualizace dat, tedy jejich
              prezentace uživateli;</p></li><li><p><span class="emphasis"><em>controller</em></span> -- aplikační logika
              starající se o obsluhu uživatelských akcí a řídící tok celé
              aplikace.</p></li></ul></div><p>Jako model jsou ve webových rámcích pro jazyk Java používány
          různé technologie, nejčastěji JSP nebo FreeMarker<sup>[<a href="#ftn.fn_freemarker">13</a>]</sup>.<sup>[<a name="fn_freemarker" href="#ftn.fn_freemarker">13</a>]</sup></p></div><div class="sect3" lang="cs"><div class="titlepage"><div><div><h4 class="title"><a name="id410538"></a>Životní cyklus požadavku</h4></div></div></div><p>Ačkoliv se v detailech mohou jednotlivé implementace lišit,
          nejčastěji probíhá zpracování požadavku v těchto krocích:</p><div class="orderedlist"><ol type="1"><li><p>uživatel se nachází na některé stránce webové aplikace a
              provede zvolenou akci (například stiskne tlačítko);</p></li><li><p>tím aplikace obdrží požadavek a upozorní komponentu
              <span class="emphasis"><em>controller</em></span>, která spustí obsluhu doručeného
              požadavku;</p></li><li><p>pokud uživatel odeslal požadavek na změnu dat
              (<span class="emphasis"><em>modelu</em></span>), <span class="emphasis"><em>controller</em></span>
              tuto operaci provede (například smaže položku z
              databáze);</p></li><li><p>poté <span class="emphasis"><em>controller</em></span> vybere stránku
              (<span class="emphasis"><em>view</em></span>), která má být uživateli
              zobrazena;</p></li><li><p>zde jsou dvě možnosti dalšího postupu:</p><div class="orderedlist"><ol type="a"><li><p><span class="emphasis"><em>controller</em></span> dodá potřebná data,
                  která se mají zobrazit v komponentě
                  <span class="emphasis"><em>view;</em></span></p></li><li><p>samotná komponenta <span class="emphasis"><em>view</em></span> si
                  potřebná data obstará, bez zásahu
                  <span class="emphasis"><em>controlleru;</em></span></p></li></ol></div></li><li><p>ze zvolené stránky a získaných dat je utvořena HTTP
              odpověď a doručena webovému prohlížeči uživatele;</p></li><li><p>aplikace čeká na další akci iniciovanou uživatelem, kruh
              se tím uzavírá.</p></li></ol></div><p>Celou situaci zpracování jednoho požadavku ilustruje obrázek
          <a href="#pic_MVC" title="Obrázek 2.2. Koncept architektury MVC">2.2 – „Koncept architektury MVC“</a>.</p><div class="figure"><a name="pic_MVC"></a><p class="title"><b>Obrázek 2.2. Koncept architektury MVC</b></p><div class="mediaobject"><table border="0" summary="manufactured viewport for HTML img" cellspacing="0" cellpadding="0" width="500"><tr><td><img src="images/mvc.png" width="500" alt="Koncept architektury MVC"></td></tr></table></div></div><p>Webové rámce založené na konceptu MVC můžeme dále rozdělit na
          dvě základní podskupiny. Tyto se navzájem liší mimo jiné v pátém
          bodu předešlého popisu zpracování požadavku, rozlišujeme tedy rámce
          založené na:</p><div class="itemizedlist"><ul type="disc"><li><p><span class="emphasis"><em>komponentách</em></span> -- také tzv.
              <span class="emphasis"><em>pull-based rámce</em></span></p></li><li><p><span class="emphasis"><em>akcích</em></span> -- jinak též tzv.
              <span class="emphasis"><em>push-based rámce</em></span></p></li></ul></div></div><div class="sect3" lang="cs"><div class="titlepage"><div><div><h4 class="title"><a name="id410804"></a>Výhody a přínosy</h4></div></div></div><p>Jaké benefity nám tedy přinese snaha o dekompozici aplikace
          podle architektury MVC? Mezi nejdůležitější přínosy patří
          tyto:</p><div class="itemizedlist"><ul type="disc"><li><p><span class="emphasis"><em>snadnější udržovatelnost</em></span> -- úprava
              jednotlivých částí je snadnější a tím i levnější;</p></li><li><p><span class="emphasis"><em>nezávislost komponent</em></span> -- je snadné
              vyměnit jednu komponentu za jinou a přitom máme zaručeno, že
              bude nová část se zbytkem systému korektně spolupracovat;</p></li><li><p><span class="emphasis"><em>znovupoužitelnost</em></span> -- jednotlivé
              komponenty je možné opakovaně použít v dalších aplikacích a tím
              snížit náklady na jejich vývoj.</p></li></ul></div></div></div><div class="sect2" lang="cs"><div class="titlepage"><div><div><h3 class="title"><a name="id410872"></a>Rámce založené na komponentách</h3></div></div></div><p>Ačkoliv je rámec Stripes je zástupcem druhé skupiny, uvedeme si
        pro srovnání rovněž krátký popis nejpoužívanějších rámců prvního typu
        -- založených na komponentách<a class="indexterm" name="id410889"></a>.</p><p>Tyto rámce mají jeden významný společný rys -- snaží se před
        vývojáři skrýt podstatu webových aplikací, tedy bezstavovost protokolu
        HTTP a jeho princip požadavek-odpověď. Na návrh webových aplikací se
        snaží tyto rámce pohlížet pomocí osvědčených postupů známých z tvorby
        běžných desktopových programů běžících v operačním systému.</p><p>Druhým společným atributem je způsob, jakým je ve webové
        aplikaci zajištěno řízení životního cyklu pomocí zvoleného rámce. Ve
        všech případech se tak děje pomocí <span class="emphasis"><em>servletu</em></span>
        případně <span class="emphasis"><em>filtru</em></span>, který musí být přidán do
        deployment deskriptoru a správně namapován k obsluze všech
        požadovaných URL uvnitř webové aplikace. Není bez zajímavosti, že s
        příchodem Servlet API 3.0 by mělo zmizet i toto omezení webových
        rámců.</p><p>Každý rámec bude moci specifikovat svůj vlastní soubor
        <span class="emphasis"><em>web.xml</em></span> umístěný mezi zdrojovými soubory ve
        složce <span class="emphasis"><em>META-INF</em></span>, který bude obsahovat všechny
        potřebné definice servletů či filtrů. Pokud bude knihovna s rámcem
        (tedy její jar soubor) přidána k webové aplikaci (tj. bude obsažena ve
        složce <span class="emphasis"><em>WEB-INF/lib</em></span> dané webové aplikace), budou
        kontejnerem při jejím nasazení přidány všechny elementy ze souboru
        <span class="emphasis"><em>web.xml</em></span> daného rámce do deployment deskriptoru
        samotné webové aplikace.</p><div class="sect3" lang="cs"><div class="titlepage"><div><div><h4 class="title"><a name="id410987"></a>Java Server Faces</h4></div></div></div><p><span class="emphasis"><em>Java Server Faces</em></span><a class="indexterm" name="id410998"></a> -- <span class="emphasis"><em>JSF</em></span> -- jsou zřejmě
          nejznámějším a nejpoužívanějším zástupcem skupiny rámců založených
          na komponentách. Nejde však o jeden konkrétní rámec, nýbrž o
          standard, který je implementován v rámci jednotlivých projektů.
          Tento standard je součástí edice Java EE, jelikož pochází přímo z
          dílny společnosti Sun, a z tohoto faktu zřejmě plyne i jeho
          rozšířenost na poli webových aplikací. Firma Sun rovněž vytvořila
          referenční implementaci tohoto standardu.</p><p>Historie JSF se začala psát v roce 2003, kdy byla jako JSR 127
          zveřejněna jeho první specifikace -- verze 1.1. Ta stavěla na Java
          SE 1.4 a Servlet API 2.4. O tři roky později byla uvedena verze 1.2,
          která již požadovala pro svůj běh Servlet API 2.5 a Java SE 5, čímž
          byla značnou dobu limitována. Implementaci obou těchto standardů
          totiž dlouhou dobu poskytoval pouze aplikační server GlassFish firmy
          Sun. V současné době (březen 2009) se již téměř dva roky pracuje na
          JSF verze 2.0 -- v rámci JSR 314.</p><p>Standard JSF je v mnohém podobný návrhu uživatelského rozhraní
          pomocí technologie <span class="emphasis"><em>Swing</em></span><a class="indexterm" name="id411048"></a>. Celá aplikace je tvořena jednotlivými komponentami,
          každá plní jasně daný díl funkcionality. Některé komponenty lze do
          sebe zanořovat (komponenta <span class="emphasis"><em>formulář</em></span> obsahuje
          komponenty <span class="emphasis"><em>textové pole</em></span>,
          <span class="emphasis"><em>tlačítko</em></span> a další), jednotlivé akce vyvolané
          uživatelem (například stisk tlačítka) vytvářejí události, na které
          pak aplikace reaguje pomocí předem registrovaných
          <span class="emphasis"><em>posluchačů</em></span>.</p><p>Pro potřeby konfigurace se používá XML soubor
          <span class="emphasis"><em>faces-config.xml</em></span>, který se nachází ve složce
          <span class="emphasis"><em>WEB-INF</em></span>. V tomto deskriptoru je definováno
          použití jednotlivých posluchačů stejně jako navigační pravidla pro
          celou aplikaci. V nové verzi 2.0 lze pozorovat zřetelnou snahu o
          omezení konfigurace v XML souboru a jejího nahrazení pomocí anotací
          deklarovaných u jednotlivých elementů tvořených tříd.</p><p>Mezi největší pozitiva tohoto standardu patří:</p><div class="itemizedlist"><ul type="disc"><li><p><span class="emphasis"><em>Rychlá tvorba webových aplikací</em></span> --
              standard poskytuje základní sadu komponent, které pokrývají
              velkou část běžně požadované funkcionality (například tlačítka
              či celé formuláře). Stejně tak je i poskytnut prostor pro tvorbu
              nových komponent. V neposlední řadě je nutné k výhodám přičíst i
              možnost využít množství nástrojů, které podporují
              <span class="emphasis"><em>vizuální tvorbu</em></span> JSF aplikací -- například
              modul <span class="emphasis"><em>Visual Web 4 JSF</em></span><sup>[<a href="#ftn.fn_visual_web">14</a>]</sup> pro NetBeans IDE.<sup>[<a name="fn_visual_web" href="#ftn.fn_visual_web">14</a>]</sup></p></li><li><p><span class="emphasis"><em>Vynucování správného zapouzdření</em></span> --
              všechno jsou komponenty, každý napsaný kód musí být v některé
              obsažen. Tím se výsledná aplikace v pozdějších fázích lépe
              udržuje.</p></li><li><p><span class="emphasis"><em>Vysoká přizpůsobitelnost</em></span> -- jakákoliv
              úroveň životního cyklu může být nahrazena libovolnou jinou,
              pokud splňuje příslušné kontrakty. Rámec JSF tak například není
              omezen na generování výstup v HTML a nemusí ke komunikaci ani
              využívat HTTP protokol.</p></li></ul></div><p>V současné době jsou k dispozici dvě implementace JSF, obě s
          kompletním přístupem ke zdrojovým kódům -- <span class="emphasis"><em>referenční
          implementace</em></span> od společnosti Sun a <span class="emphasis"><em>Apache
          MyFaces</em></span>.</p><p>Jelikož JSF je standard, je k dispozici celá řada knihoven,
          které obsahují implementaci nových komponent. Ty lze využít v
          libovolné aplikaci řídící se standardem JSF. Mezi nejznámější
          knihovny komponent lze zařadit tyto:</p><div class="itemizedlist"><ul type="disc"><li><p><span class="emphasis"><em>RichFaces</em></span> -- <a href="http://www.jboss.org/jbossrichfaces/" target="_top">http://www.jboss.org/jbossrichfaces/</a>;</p></li><li><p><span class="emphasis"><em>ICEfaces</em></span> -- <a href="http://www.icefaces.org/" target="_top">http://www.icefaces.org/</a>.</p></li></ul></div><p>Velmi časté je obohacení základního standardu JSF o další
          principy, které ještě více usnadňují tvorbu webových aplikací --
          například možnost využívat k zobrazování dat HTML soubory místo
          standardních JSP stránek. Mezi nejběžnější rozšíření standardu JSF
          patří:</p><div class="itemizedlist"><ul type="disc"><li><p><span class="emphasis"><em>Facelets</em></span> -- <a href="https://facelets.dev.java.net/" target="_top">https://facelets.dev.java.net/</a>;</p></li><li><p><span class="emphasis"><em>JBoss Seam</em></span> -- <a href="http://www.jboss.com/products/seam/" target="_top">http://www.jboss.com/products/seam/</a>.</p></li></ul></div><p>Poměrně často diskutovaným tématem ve spojení se standardem
          JSF je jeho vysoká výpočetní náročnost. Zajímavé je srovnání
          <span class="emphasis"><em>Apache MyFaces</em></span> s rámcem
          <span class="emphasis"><em>Wicket</em></span>, které lze nalézt v <a href="#bib_JSFVWIC">JSFVWIC</a>.</p><p>Podrobnější informace o standardu Java Server Faces, jeho
          rysech a možnostech lze nalézt třeba v <a href="#bib_JSF">JSF</a>.</p></div><div class="sect3" lang="cs"><div class="titlepage"><div><div><h4 class="title"><a name="id411384"></a>Tapestry</h4></div></div></div><p>Dalším zástupcem komponentních webových rámců je
          <span class="emphasis"><em>Tapestry</em></span><a class="indexterm" name="id411398"></a>. Jde o silně objektově orientovaný rámec, který v
          nejnovější verzi 5 klade důraz především na jednoduchost, snadnost
          použití a omezení rozsahu neefektivního kódu.</p><p>Tapestry celou aplikaci vidí jako kolekci
          <span class="emphasis"><em>stránek</em></span> a <span class="emphasis"><em>komponent</em></span>.
          <span class="emphasis"><em>Stránky</em></span> jsou šablonami, které definují
          rozložení dat na stránce, tedy jejich vizuální podobu.
          <span class="emphasis"><em>Komponenty</em></span> se starají pouze o funkcionalitu.
          Komponenty se dále dělí na <span class="emphasis"><em>základní</em></span> a
          <span class="emphasis"><em>pomocné</em></span>. <span class="emphasis"><em>Základní</em></span> poté
          poskytují veškerou výkonnou funkcionalitu webové aplikace, jako
          například validaci formulářů, persistenci objektů či navigaci.
          Pomocné komponenty definují pravidla, podle kterých mezi sebou mohou
          komunikovat jednotlivé <span class="emphasis"><em>základní</em></span>
          komponenty.</p><p>Velmi podstatnou výhodou tohoto rámce je fakt, že jako šablony
          uživatelského rozhraní -- jednotlivé komponenty typu
          <span class="emphasis"><em>stránka</em></span> -- jsou použity
          <span class="emphasis"><em>XHTML</em></span> soubory, nikoliv JSP. Tím se podstatně
          usnadňuje spolupráce <span class="emphasis"><em>návrháře vzhledu</em></span> a
          <span class="emphasis"><em>vývojáře</em></span>. Vývojář vytvoří postupně sadu XHTML
          stránek, které využívá k zobrazování dat. Ty poté poskytne návrháři,
          aby pro ně vytvořil příslušné styly. Návrhář vrátí vývojáři
          vytvořený CSS styl, který je zakomponován do webové aplikace.
          Vytvářet CSS styl pro XHTML stánku je podstatně pohodlnější a
          rychlejší, než pro JSP. Návrhář může používat všechny své oblíbené
          vizuální nástroje a nemusí se jakkoliv starat o samotnou webovou
          aplikaci -- instalovat kontejner, aplikaci na něm nasazovat
          apod.</p><p>Krátká ukázka XHTML značkování demonstrující tuto
          funkcionalitu může vypadat například takto:</p><pre class="programlisting">&lt;table&gt;
  &lt;tr&gt;
    &lt;th&gt;First Name&lt;/th&gt;
    &lt;th&gt;Last Name&lt;/h&gt;
  &lt;/tr&gt;
  &lt;tr jwcid="loop"&gt;
    &lt;td&gt;&lt;span jwcid="insertFirstName"&gt;John&lt;/span&gt;&lt;/td&gt;
    &lt;td&gt;&lt;span jwcid="insertLastName"&gt;Doe&lt;/span&gt;&lt;/td&gt;
  &lt;/tr&gt;
  &lt;tr jwcid="$remove$"&gt;
    &lt;td&gt;Frank&lt;/td&gt;
    &lt;td&gt;Smith&lt;/td&gt;
  &lt;/tr&gt;
  &lt;tr jwcid="$remove$"&gt;
    &lt;td&gt;Jane&lt;/td&gt;
    &lt;td&gt;Jones&lt;/td&gt;
  &lt;/tr&gt;
&lt;/table&gt;</pre><p>Návrhář uvidí při zobrazení tohoto kódu jednoduchou tabulku o
          dvou sloupcích a třech řádcích, kterou snadno vizuálně upraví podle
          své libosti. Ve webové aplikaci je však před zobrazením tato tabulka
          zpracována odlišně. Druhý a třetí řádek (nepočítáme-li v úvahu řádek
          s nadpisy sloupečků) se nezobrazí a místo prvního řádku se zobrazí
          postupně všechny záznamy definované komponentou
          <span class="emphasis"><em>loop</em></span> tak, že v prvním sloupci se vypíše křestní
          jméno a ve druhém příjmení. Toho vše je dosaženo pouze vhodným
          užitím atributu <span class="emphasis"><em>jwcid</em></span> u jednotlivých značek,
          případně dalších rámcem rozeznávaných atributů
          (<span class="emphasis"><em>value</em></span>, <span class="emphasis"><em>key</em></span> apod.).</p><p>Kompletní dokumentaci včetně příkladů použití lze nalézt na
          webových stránkách uvedených v <a href="#bib_TAP">TAP</a>.</p></div><div class="sect3" lang="cs"><div class="titlepage"><div><div><h4 class="title"><a name="id411602"></a>Wicket</h4></div></div></div><p><span class="emphasis"><em>Wicket</em></span><a class="indexterm" name="id411612"></a> je posledním nástrojem zmíněným ve výčtu rámců, které
          budují webovou aplikaci pomocí komponent. Ten je v mnoha ohledech
          podobný předešlému rámci <span class="emphasis"><em>Tapestry</em></span> a tím i
          filozofii návrhu komponent <span class="emphasis"><em>Swing</em></span>.</p><p>K vykreslování komponent do XHTML stránek je také používán
          speciální atribut. Tím je zachována výhoda tvorby XHTML návrhu v
          libovolném editoru. Jediným rozdílem oproti Tapestry je fakt, že
          Wicket má svůj atribut obsažen ve vlastním jmenném prostoru -- celý
          se tak typicky uvádí jako <span class="emphasis"><em>wicket:id</em></span>. Krátký
          úsek XHTML značkování obsahující vykreslení komponenty Wicket vypadá
          například následovně:</p><pre class="programlisting">&lt;span <span class="emphasis"><em>wicket:id</em></span>="message" id="message"&gt;
    This text will be replaced with actual message
&lt;/span&gt;</pre><p>Komponenta vykreslující konkrétní zprávu pak může vypadat
          například takto:</p><pre class="programlisting">package com.my.web.wicket;
 
import org.apache.wicket.markup.html.WebPage;
import org.apache.wicket.markup.html.basic.Label;
 
public class MessagingPage extends WebPage {
    /**
     * Constructor
     */
    public MessagingPage() {
        add(new Label("message", "Hello World!"));
    }
}</pre><p>Hlavní výhodou a podstatnou odlišností rámce Wicket je snaha o
          kompletní odstínění vývojáře od <span class="emphasis"><em>správy stavu
          aplikace</em></span>. Vývojář tak například nikdy nemusí pracovat
          přímo s objektem typu <span class="emphasis"><em>HttpSession</em></span>, celá správa
          stavu aplikace je prováděna v režii samotného rámce. Každá
          komponenta má svůj vlastní stav, navigační stav celé aplikace je pak
          držen pro každého uživatele zvlášť v jeho
          <span class="emphasis"><em>sezení</em></span>. Vývojář tak vždy pracuje pouze s
          komponentami vytvořenými v jazyce Java a o vše nezbytné se stará
          rámec.</p><p>Toto řešení přináší ještě jednu výhodu -- rámec Wicket poměrně
          robustně řeší <span class="emphasis"><em>problém tlačítka Zpět</em></span>. Sám
          kontroluje, zda platnost dat na stránce již nevypršela a místo
          načtení stránky z vyrovnávací paměti provede jejich kompletní
          obnovení (například z databáze).</p><p>Zvolený návrh rámce s sebou ovšem přináší větší režii na
          straně kontejneru -- někdy se stará o zbytečně mnoho informací,
          které aplikace třeba vůbec ani nevyužívá. Na druhé straně, v dnešní
          době je hardware většinou výrazně levnější než práce programátorů, a
          proto se vyplatí za cenu serverového vybavení snížit náklady na
          vývoj webové aplikace.</p><p>Podrobnější informace spolu s odkazy na další zdroje lze
          nalézt například v <a href="#bib_WIC">WIC</a>.</p></div></div><div class="sect2" lang="cs"><div class="titlepage"><div><div><h3 class="title"><a name="id411781"></a>Rámce založené na akcích</h3></div></div></div><p>V této podkapitole si blíže představíme rámce<a class="indexterm" name="id411793"></a>, které jsou založené na zcela jiné filozofii, než první
        skupina. Nesnaží se na webovou aplikaci pohlížet jako na sadu
        komponent, spíše ji vidí jako skupinu obslužných entit, které reagují
        na jednotlivé HTTP požadavky odesílané uživateli.</p><p>Jak bylo vysvětleno v podkapitole <a href="#http" title="Protokol HTTP">„Protokol HTTP“</a>,
        komunikace webového prohlížeče a aplikace je založena na odesílání
        požadavků a navracení odpovědí. <span class="emphasis"><em>Rámce založené na
        akcích</em></span> se snaží tento koncept dále rozvinout, jejich hlavní
        snahou je oprostit vývojáře od nutnosti práce s nízkoúrovňovou
        obsluhou požadavků -- se servlety.</p><p>Mapování jednotlivých požadavků na obslužné entity je opět
        dosaženo -- podobně jako u rámců založených na komponentách --
        přidáním servletu či filtru do deployment deskriptoru webové aplikace
        a jeho vhodným svázáním s tvarem obsluhovaných URL.</p><div class="sect3" lang="cs"><div class="titlepage"><div><div><h4 class="title"><a name="id411850"></a>Struts</h4></div></div></div><p>Patrně historicky nejstarším a nejznámějším zástupcem této
          skupiny rámců jsou <span class="emphasis"><em>Struts</em></span><a class="indexterm" name="id411865"></a>. Jejich původ sahá až do května roku 2000, kdy byla
          uvedena první verze stvořená Craigem McClanahanem. Později projekt
          přešel pod křídla <span class="emphasis"><em>Apache Software Foundation</em></span>,
          kde se v roce 2005 stal jedním z hlavních projektů a dále nesl název
          <span class="emphasis"><em>Jakarta Struts</em></span>. V současné době je k dispozici
          již verze <span class="emphasis"><em>Struts2</em></span>, která však není přímým
          nástupcem původního rámce. Tento rámec vznikl přejmenováním projektu
          <span class="emphasis"><em>WebWork</em></span>, rovněž z dílny korporace
          Apache.</p><p>Častou součástí webové aplikace jsou formuláře. Než vznikly
          první webové rámce, o obsluhu formulářů se staraly buď servlety,
          nebo JSP stránky. Vyhodnotily data, případně provedly nějakou
          interakci s databází a vygenerovaly HTML výstup srozumitelný pro
          uživatele. Obě metody zpracování velmi často vedly ke spojování
          aplikační logiky s generováním výstupu. Tomu se pokusil webový rámec
          Struts udělat rázný konec.</p><p>Hlavním cílem rámce Struts je vynucení přístupu MVC. Tedy
          oddělení komponent <span class="emphasis"><em>model</em></span>,
          <span class="emphasis"><em>view</em></span> a <span class="emphasis"><em>controller</em></span>.
          <span class="emphasis"><em>Modelem</em></span> zde jsou všechna doménová data, která
          se získávají prostřednictvím nižší vrstvy webové aplikace --
          <span class="emphasis"><em>backendu</em></span>. Tím může být například servisní
          webová aplikace -- viz kapitola <a href="#webapps" title="Definice webové aplikace">„Definice webové aplikace“</a>.
          Komponentu <span class="emphasis"><em>view</em></span> tvoří HTML šablony, nejčastěji
          JSP stránky (ale i XML či Velocity), které pouze zobrazují
          poskytnutá data <span class="emphasis"><em>modelu</em></span>. Součástí komponenty
          <span class="emphasis"><em>controller</em></span> je v první řadě třída
          <code class="classname">ActionServlet</code>, která je zaregistrována jako
          servlet v souboru <span class="emphasis"><em>web.xml</em></span> a typicky obsluhuje
          všechny URL končící na <code class="classname">.do</code>. Každý požadavek
          zpracovávaný tímto servletem je poté odeslán ke zpracování konkrétní
          obslužné třídě. Tyto jsou tvořeny vývojářem webové aplikace a rovněž
          jsou součástí komponenty <span class="emphasis"><em>controller</em></span>.</p><p>Srdcem konfigurace celého rámce je v každé webové aplikaci
          soubor <span class="emphasis"><em>struts-config.xml</em></span>, který musí být
          umístěn ve složce <span class="emphasis"><em>WEB-INF</em></span>. V tomto
          konfiguračním souboru se nachází mapování mezi
          <span class="emphasis"><em>akcemi</em></span> a obslužnými třídami. Obslužné třídy
          musejí být potomkem třídy
          <code class="classname">org.apache.struts.action.Action</code> a nejčastěji
          překrývají metodu <span class="emphasis"><em>execute()</em></span>. Tato je zavolána
          obslužným servletem při příchodu požadavku určeného pro danou
          obslužnou třídu. Konkrétní akci lze vyvolat vytvořením požadavku na
          URL, jejíž část před příponou <code class="classname">.do</code> je shodná s
          názvem akce.</p><p>V konfiguračním souboru je dále uvedeno, které JSP stránky se
          mají zobrazit po proběhnutí konkrétních akcí. Také mohou být
          definovány obslužné třídy pro jednotlivé formuláře --
          <span class="emphasis"><em>form-beans</em></span>. Konkrétní část souboru
          <span class="emphasis"><em>struts-config.xml</em></span> může vypadat například
          takto:</p><pre class="programlisting">&lt;struts-config&gt;
   ...
   &lt;form-beans&gt;
     &lt;form-bean name="userData" type="com.my.web.struts.UserDataForm" /&gt;
    ...
   &lt;/form-beans&gt;

   &lt;action-mappings&gt;
   ...
     &lt;action path="/checkRepairStatus" 
           type="com.my.web.struts.CheckStatusAction"&gt;
       &lt;forward name="finished" path="repair-finished.jsp" /&gt;
       &lt;forward name="pending" path="repair-pending.jsp" /&gt;
     &lt;/action&gt;
   ...</pre><p>Máme-li v naší webové aplikaci správně nastaven
          <span class="emphasis"><em>controller</em></span> pro rámec Struts a jeho konfigurační
          soubor obsahuje zmíněnou definici, bude se aplikace chovat
          následovně. Pokud zavoláme URL
          <code class="classname">/checkRepairStatus.do</code>, pak to způsobí
          vyvolání metody <span class="emphasis"><em>execute()</em></span> ze třídy
          <code class="classname">com.my.web.struts.CheckStatusAction</code>. Ta
          zkontroluje stav opravy v databázi. Pokud je již předmět opraven,
          nahrají se z databáze potřebná data (informace o závadě, cena opravy
          apod.), tato data se nastaví jako atribut HTTP request objektu
          poskytnutého metodě <span class="emphasis"><em>execute()</em></span> a metoda vrátí
          identifikátor <span class="emphasis"><em>finished</em></span>. Pokud předmět není
          opraven, vrátí metoda identifikátor <span class="emphasis"><em>pending</em></span>.
          Řídící servlet pak podle identifikátoru vráceného metodou předá
          vyřízení požadavku na stránku
          <span class="emphasis"><em>repair-finished.jsp</em></span> nebo
          <span class="emphasis"><em>repair-pending.jsp</em></span>.</p><p>Jak již bylo zmíněno dříve, velmi častým scénářem ve webových
          aplikacích je vkládání dat pomocí formuláře a jejich následné
          zpracování. I na tento způsob využití je rámec Struts připraven. Jak
          bylo napsáno o několik odstavců výše, v souboru
          <span class="emphasis"><em>struts-config.xml</em></span> lze definovat komponenty
          <span class="emphasis"><em>form-beans</em></span>. Specifikovaná třída je pak určená
          především k validaci dat. Pokud validace selže, formulář je zobrazen
          znovu s předvyplněnými daty a zvýrazněním těch položek, které byly
          vyplněny nesprávně. Pokud validace uspěje, je zavolána metoda
          <span class="emphasis"><em>execute()</em></span> ze třídy určené podle postupu
          popsaného v předešlém odstavci.</p><p>Ke správnému zobrazování dat ve formulářích je nutné místo
          běžných HTML značek používat elementy z knihovny značek, která je
          součástí rámce Struts. Velmi pěkně jsou možnosti rámce Struts
          shrnuty v <a href="#bib_STRFI">STRFI</a>.</p><p>Velkou snahou <span class="emphasis"><em>Struts2</em></span> je omezení rozsahu
          konfigurací v souboru <span class="emphasis"><em>struts-config.xml</em></span> a
          užívání anotací u jednotlivých obslužných tříd. U velkých projektů
          se počet různých akcí může rapidně zvyšovat a konfigurační soubor se
          tak snadno stává nepřehledným a nesnadno udržovatelným.</p><p>Rámec taktéž obsahuje podporu pro tvorbu šablon jednotlivých
          stránek -- <span class="emphasis"><em>Tiles</em></span>. Pokud se tedy na nějaké
          skupině stránek používá stejné rozložení, lze pro ně nadefinovat
          šablonu a v jednotlivých souborech pak mít pouze kód pro zobrazování
          obsahu, kterým se jednotlivé stránky odlišují. Tiles používají k
          definici šablon samostatný soubor nesoucí název
          <span class="emphasis"><em>tiles-defs.xml</em></span>, který se nachází ve stejné
          složce jako <span class="emphasis"><em>struts-config.xml</em></span>.</p><p>Kompletní dokumentaci a mnoho příkladů lze nalézt na oficiální
          stránce projektu odkazované v <a href="#bib_STR">STR</a>.</p></div><div class="sect3" lang="cs"><div class="titlepage"><div><div><h4 class="title"><a name="id412310"></a>Spring Web MVC</h4></div></div></div><p>Webový rámec <span class="emphasis"><em>Spring Web MVC</em></span><a class="indexterm" name="id412322"></a>, jak už název napovídá, v mnohém vychází v velmi
          známého a používaného nástroje <span class="emphasis"><em>Spring</em></span>. Jeho
          velkou zbraní je právě možnost jednoduchého a přímočarého napojení
          na aplikační logiku, pokud je tato implementována pomocí rámce
          <span class="emphasis"><em>Spring</em></span>. Mnoho rysů nástroje Spring Web MVC
          vychází přímo z rámec Spring, proto si tento nejprve ve zkratce
          přiblížíme.</p><p>Hlavní motivací, která vedla vývojáře k započetí práce na
          rámci <span class="emphasis"><em>Spring</em></span>, bylo poskytnout vývojářům
          pomocnou ruku v psaní velkých a přesto dobře dekomponovaných
          webových aplikací. V mnohém se podobá technologii
          <span class="emphasis"><em>EJB</em></span>, která si klade za cíl podobné mety. Rámec
          Spring má však tu výhodu, že je velmi <span class="emphasis"><em>lehký</em></span>.
          Není součástí žádného kontejneru, on sám je de facto webovým
          kontejnerem, protože aplikacím zajišťuje stejné služby. Avšak lze ho
          přidat ve formě jar archivů k libovolné aplikací (ať webové či
          desktopové) a aplikace může plně využívat jeho služeb. Mezi služby
          poskytované rámcem Spring patří zejména tyto:</p><div class="itemizedlist"><ul type="disc"><li><p><span class="emphasis"><em>Inversion of Control</em></span> -- o závislosti
              mezi třídami se nestarají třídy samotné, ale externí komponenta,
              která instanci třídy vždy poskytne všechny implementace služeb,
              na kterých je třída závislá. Tento princip vystihuje anglická
              fráze „<span class="quote">Don't call us, we will call you</span>“. Více o
              tomto přístupu k budování aplikací viz <a href="#bib_IOC">IOC</a>.</p></li><li><p><span class="emphasis"><em>Aspect-oriented programming</em></span> -- snaha
              o rozvinutí objektově orientovaného programování směrem k
              dalšímu striktnímu oddělení jednotlivých částí aplikace a jejich
              centrální správy. Více informací o tomto novém paradigmatu lze
              nalézt například v <a href="#bib_AOP">AOP</a>.</p></li><li><p><span class="emphasis"><em>Přístup k datům</em></span> -- rámec umožňuje v
              průběhu tvorby aplikace měnit typ napojení na databázi. Je tak
              možné plynule přejít od <span class="emphasis"><em>JBDC</em></span> k
              <span class="emphasis"><em>JDO</em></span> a později k implementaci pomocí
              <span class="emphasis"><em>Hibernate</em></span>.</p></li><li><p><span class="emphasis"><em>Řízení transakcí</em></span> -- Spring sjednocuje
              jednotlivá API a stará se o vykonávání transakčních operací nad
              jednotlivými objekty jazyka Java.</p></li><li><p><span class="emphasis"><em>Autentizace a autorizace</em></span> -- rámec
              poskytuje konfigurovatelný a vynutitelný nástroj na správu
              uživatelských identit a jednotlivých oprávnění.</p></li><li><p><span class="emphasis"><em>Podpora pro testování</em></span> -- Spring
              poskytuje řadu možností, jak aplikaci testovat, například pomocí
              nástrojů <span class="emphasis"><em>JUnit</em></span> či
              <span class="emphasis"><em>TestNG.</em></span></p></li></ul></div><p>Ačkoliv byl v seznamu bod <span class="emphasis"><em>podpora pro
          testování</em></span> uveden až jako poslední, právě nutnost důkladně
          testovat aplikace se stává čím dál důležitější. Zřejmě není třeba
          zdůrazňovat význam známého pravidla, které říká, že čím dříve se v
          aplikaci chyba objeví, tím snadnější a lacinější je ji opravit. A
          právě možnost pohodné tvorby a spouštění jednotlivých testů mimo
          kontejner (kterým je například GlassFish) dělá z rámce Spring
          zdatného konkurenta technologii EJB.</p><p>Nyní již se budeme zabývat podmnožinou rámce Spring, který se
          stará o vhodnou dekompozici prezenční části webové aplikace. Celá
          práce webového rámce Spring Web MVC je soustředěna kolem dvou bodů
          webové aplikace. Prvním je servlet
          <code class="classname">DispatcherServlet</code> z balíku
          <code class="classname">org.springframework.web.servlet</code>, který je
          nutno přidat do deployment deskriptoru a namapovat na požadovaný
          tvar URL, podobně jako je tomu u rámce Struts. Druhým stěžejním
          bodem je XML deskriptor (nejčastěji pojmenovaný
          <span class="emphasis"><em>spring-servlet.xml</em></span>), který obsahuje deklaraci
          všech tříd potřebných pro obsluhu jednotlivých požadavků.</p><p>Syntaxe konfiguračního souboru je převzata z rámce Spring,
          obsahuje kolekci elementů <span class="emphasis"><em>bean</em></span>, u kterých je
          vždy deklarován jejich jedinečný název v rámci celé aplikace. U
          jednotlivých <span class="emphasis"><em>bean</em></span> elementů může být
          deklarováno, jaké jiné <span class="emphasis"><em>bean</em></span> instance mají být
          při vytvoření do daného objektu injektovány. Tím je velmi snadno a
          přehledně zrealizován princip <span class="emphasis"><em>Inversion of
          Control</em></span> popsaný výše. V tomto konfiguračním souboru se
          lze odkazovat na libovolné bean instance z jiných konfiguračních
          souborů rámce Spring.</p><p>Do třídy obsluhující HTTP požadavek se tak typicky injektují
          vždy implementace jednotlivých servisních tříd, které jsou potřeba k
          obsluze daného požadavku (například uložení položky do databáze) a
          byly deklarovány jako <span class="emphasis"><em>bean</em></span> instance v
          konfiguračním souboru rámce Spring v aplikační části webové
          aplikace.</p><p>V konfiguračním souboru webového rámce Spring Web MVC lze
          rozlišit tyto významné elementy:</p><div class="itemizedlist"><ul type="disc"><li><p><span class="emphasis"><em>Controller</em></span> -- jde o třídy napsané
              vývojářem webové aplikace, které obsluhují určitou podskupinu
              požadavků.</p></li><li><p><span class="emphasis"><em>Handler mapping</em></span> -- jsou deklarace
              podmínek, za kterých bude pro obsluhu požadavku použit daný
              <span class="emphasis"><em>controller</em></span>. Vymezující podmínkou může být
              například tvar URL nebo hodnota nějakého parametru.</p></li><li><p><span class="emphasis"><em>View resolver</em></span> -- tyto elementy
              zabezpečují mapování názvů komponent <span class="emphasis"><em>view</em></span>
              na konkrétní soubory (například JSP stránky nebo šablony
              Velocity).</p></li><li><p><span class="emphasis"><em>Locale resolver</em></span> -- starají se o volbu
              jazyka uživatelského rozhraní.</p></li><li><p><span class="emphasis"><em>Theme resolver</em></span> -- jejich úkolem je
              práce s různými vzhledy webové aplikace, pokud jich tato
              poskytuje více.</p></li><li><p><span class="emphasis"><em>Multipart file resolver</em></span> -- slouží k
              obsluze požadavků obsahujících binární data ze souborů nahraných
              na server pomocí HTML formuláře.</p></li><li><p><span class="emphasis"><em>Handler exception resolver</em></span> -- stará
              se o obsluhu výjimek vzniklých ve webové aplikaci.</p></li></ul></div><p>Rámec taktéž disponuje podporou pro zjednodušenou obsluhu
          formulářových dat a jejich validaci, tvorbu formulářů tvořených více
          stránkami a podobně.</p><p>Nemalou výhodou je rovněž fakt, že tento webový rámec má svou
          variantu i pro čím dál více rozšířené portálové aplikace<sup>[<a href="#ftn.fn_portletAPI">15</a>]</sup>. Vývojář znalý rámce <span class="emphasis"><em>Spring Web
          MVC</em></span> tak může s téměř nulovou režií přejít na
          <span class="emphasis"><em>Spring Portlet MVC</em></span> a tvořit, stejným postupem
          jako dosud, portálové aplikace.<sup>[<a name="fn_portletAPI" href="#ftn.fn_portletAPI">15</a>]</sup></p><p>Velkou devizou celého projektu Spring je rozsáhlá a velmi
          kvalitní dokumentace, která obsahuje spoustu příkladů s konkrétním
          využitím jednotlivých rysů rámce. Nejlepším zdrojem informací pro
          kompletní referenci o rámci Spring Web MVC jsou kapitoly z oficiální
          dokumentace uvedené v <a href="#bib_SPRING">SPRING</a>.</p></div></div></div><div class="footnotes"><br><hr width="100" align="left"><div class="footnote"><p><sup>[<a name="ftn.fn_JSAPI" href="#fn_JSAPI">1</a>] </sup>Verze 2.2 vznikala průběžně během roku 2000, viz následující
          podkapitola <a href="#servlets" title="Java Servlet API">„Java Servlet API“</a>.</p></div><div class="footnote"><p><sup>[<a name="ftn.fn_jsr" href="#fn_jsr">2</a>] </sup>JSR je zkratkou ze slov <span class="emphasis"><em>Java Specification
          Request</em></span>. Jde o produkt vycházející z <span class="emphasis"><em>Java
          Community Process</em></span>, což je otevřený proces tvorby norem
          pro jazyk Java. Více viz <a href="#bib_JSR">JSR</a>.</p></div><div class="footnote"><p><sup>[<a name="ftn.fn_classloader" href="#fn_classloader">3</a>] </sup>Více o principech načítání tříd v Javě a konceptu
                  virtuálních strojů lze nalézt například v <a href="#bib_CLLDR">CLLDR</a>.</p></div><div class="footnote"><p><sup>[<a name="ftn.fn_MIME" href="#fn_MIME">4</a>] </sup><span class="emphasis"><em>Multipurpose Internet Mail
              Extensions</em></span>, více viz například <a href="#bib_MIME">MIME</a>.</p></div><div class="footnote"><p><sup>[<a name="ftn.fn_jsp_xml_syntax" href="#fn_jsp_xml_syntax">5</a>] </sup>Tabulku srovnávající obě syntaxe lze nalézt například v
            <a href="#bib_JSPSYNT">JSPSYNT</a>. Jedná se však pouze o JSP verze
            1.2.</p></div><div class="footnote"><p><sup>[<a name="ftn.fn_beans" href="#fn_beans">6</a>] </sup>Java Bean je třída s bezparametrickým konstruktorem, která
              pro čtení s zápis svých parametrů využívá pouze metod --
              <span class="emphasis"><em>getterů</em></span> a <span class="emphasis"><em>setterů</em></span>.
              Více o Java Beans viz například <a href="#bib_JBNS">JBNS</a>.</p></div><div class="footnote"><p><sup>[<a name="ftn.fn_resource_bundle" href="#fn_resource_bundle">7</a>] </sup>Více o lokalizaci v Javě viz JavaDoc edice J2SE -- <a href="#bib_RBNDL">RBNDL</a>.</p></div><div class="footnote"><p><sup>[<a name="ftn.fn_anottations" href="#fn_anottations">8</a>] </sup>Anotace jsou novým syntaktickým prvkem jazyka Java od
              verze 1.5. Jde o meta informace, které mohou být přidány k řadě
              prvků: třídám, metodám, atributům tříd a dalším. Více viz
              například <a href="#bib_ANOT">ANOT</a>.</p></div><div class="footnote"><p><sup>[<a name="ftn.fn_SEO" href="#fn_SEO">9</a>] </sup>SEO je soubor technik, které mají webovou stránku či celou
              aplikaci učinit lépe viditelnou pro internetové vyhledávače.
              Mezi etické metody patří kvalitní obsah, validní (X)HTML kód,
              sémantické značkování obsahu, poskytnutí meta informací o obsahu
              stránek nebo krátké a výstižné URL. Více lze nalézt například v
              <a href="#bib_SEO">SEO</a>.</p></div><div class="footnote"><p><sup>[<a name="ftn.fn_ajax_libs" href="#fn_ajax_libs">10</a>] </sup>Oficiální stránky zmíněných projektů lze nalézt na
              následujících stránkách: <a href="http://jquery.com/" target="_top">jQuery</a>, <a href="http://www.dojotoolkit.org/" target="_top">DOJO</a>, <a href="http://www.prototypejs.org/" target="_top">Prototype</a>.</p></div><div class="footnote"><p><sup>[<a name="ftn.fn_ORM" href="#fn_ORM">11</a>] </sup>Objektově-relační mapování -- <span class="emphasis"><em>ORM</em></span> --
              je způsob, jak nakládat s relačními databázovými daty jako s
              běžnými objekty programovacího jazyka. Více viz <a href="#bib_ORM">ORM</a>.</p></div><div class="footnote"><p><sup>[<a name="ftn.fn_design_patterns" href="#fn_design_patterns">12</a>] </sup>O návrhových vzorech při vývoji software bylo napsáno již
            mnoho knih a spoustu informací lze nalézt i na webu, například v
            <a href="#bib_DP">DP</a>.</p></div><div class="footnote"><p><sup>[<a name="ftn.fn_freemarker" href="#fn_freemarker">13</a>] </sup>FreeMarker je technologie v základu podobná JSP, pouze s
              jinou syntaxí. Umožňuje specifikovat šablony obsahující jak
              statická tak i dynamická data. Engine pro zpracování šablon poté
              při zobrazení konkrétní instance šablony nahradí dynamický obsah
              dodanými daty. Oproti čistému JSP (bez JSTL apod.) obsahuje
              podporu pro cykly, větvení, rekurzi a další. Více viz stránky
              projektu na webu <a href="http://freemarker.sourceforge.net/" target="_top">http://freemarker.sourceforge.net/</a>.</p></div><div class="footnote"><p><sup>[<a name="ftn.fn_visual_web" href="#fn_visual_web">14</a>] </sup>Zjednodušeně lze vizuální tvorbu webových aplikací
                  přirovnat k WYSIWYG editoru -- vývojář tvoří uživatelské
                  rozhraní a ihned vidí, jak bude daná stránka vypadat,
                  konkrétní kód pak za něj generuje IDE.</p></div><div class="footnote"><p><sup>[<a name="ftn.fn_portletAPI" href="#fn_portletAPI">15</a>] </sup>Portálovou aplikací je míněna webové aplikace podle JSR
              168 či 286, více viz například <a href="#bib_PORT">PORT</a>.</p></div></div></div><div class="chapter" lang="cs"><div class="titlepage"><div><div><h2 class="title"><a name="stripes"></a>Kapitola 3. Rámec Stripes</h2></div></div></div><p>Jedním ze zástupců skupiny webových rámců, které jsou založené na
    akcích, je rámec <span class="emphasis"><em>Stripes</em></span><a class="indexterm" name="id412888"></a>. Jeho hlavním cílem je snaha o co největší zjednodušení
    tvorby webových aplikací na platformě Java. Funkcionalita a koncepty
    zavedené rámcem již nejsou v současné době zcela unikátní, protože řadu
    povedeních rysů převzaly ostatní nástroje -- včetně rámců Struts či Spring
    Web MVC zmíněných v předešlé kapitole. Stále však jde o živý projekt,
    který má své zastánce a neustále se vyvíjí a zdokonaluje.</p><p>Rámec se snaží držet krok s nejnovějšími technologiemi zaváděnými do
    platformy Java. Mezi ně v počátcích jeho návrhu (rok 2005) patřilo
    poskytování meta informací ve formě <span class="emphasis"><em>anotací</em></span> a užívání
    <span class="emphasis"><em>generických typů</em></span>, které v jazyce Java přibyly od jeho
    verze 5.0. Rámec si také vzal za příklad některé rysy populárního
    prostředí <span class="emphasis"><em>Ruby on Rails</em></span>, především přístup
    <span class="emphasis"><em>convention-over-configuration</em></span>. Jeho princip bude
    vysvětlen a ilustrován dále.</p><p>Jedním z hlavních odlišností od ostatních rámců je fakt, že není
    třeba používat žádný XML deskriptor pro konfiguraci rámce ve webové
    aplikaci (pokud pomineme nezbytnou definici servletu případně filtru v
    souboru web.xml). Jako konfigurace slouží pouze soubor anotací, které jsou
    specifikovány u jednotlivých obslužných tříd -- <span class="emphasis"><em>action
    bean</em></span> objektů. Navíc je uplatňován přístup
    <span class="emphasis"><em>convention-over-configuration</em></span>, tedy pokud není nějaké
    nastavení specifikováno, použije se automaticky vhodná výchozí hodnota. V
    některé literatuře lze tento princip najít i pod názvem
    <span class="emphasis"><em>configuration-by-exception</em></span>. Příkladem může být
    anotace <code class="classname">@UrlBinding</code>, která slouží u
    <span class="emphasis"><em>action bean</em></span> třídy k nastavení URL, kterou bude daná
    třída obsluhovat. Pokud tato anotace chybí, pak třída obsluhuje URL
    vytvořenou kombinací části názvu balíku a třídy -- třída
    <code class="classname">com.my.web.action.auth.UserActionBean</code> tak bude
    namapována na URL <span class="emphasis"><em>/auth/User.action</em></span>.</p><p>Nejnovější stabilní verze rámce nese označení 1.5.1 a byla vydána v
    březnu roku 2009, velmi rozšířená a používaná je i předešlá verze
    1.4.3.</p><div class="sect1" lang="cs"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="id413013"></a>Hlavní koncepty rámce Stripes</h2></div></div></div><p>Základním stavebním kamenem webové aplikace, která využívá rámec
      <span class="emphasis"><em>Stripes</em></span>, jsou prosté třídy Java, které musí pouze
      implementovat předepsané rozhraní <code class="classname">ActionBean</code> z
      balíku <code class="classname">net.sourceforge.stripes.action</code>. Tento fakt
      umožňuje, aby vytvořené třídy mohly dědit funkcionalitu z libovolné jiné
      třídy a vývojář nebyl nijak omezován co se objektového návrhu týče. Nyní
      si toto rozhraní a návrh jeho implementací blíže popíšeme.</p><div class="sect2" lang="cs"><div class="titlepage"><div><div><h3 class="title"><a name="id413052"></a>Action beans</h3></div></div></div><p>Rozhraní <code class="classname">ActionBean</code><a class="indexterm" name="id413064"></a> má pouze dvě metody, které je nutno
        implementovat:</p><pre class="programlisting">public ActionBeanContext getContext();
public void setContext(ActionBeanContext ctx);</pre><p>Metoda <span class="emphasis"><em>setContext()</em></span> je zavolána rámcem
        pokaždé při vytváření <span class="emphasis"><em>action bean</em></span> instance a daný
        parametr typu <code class="classname">ActionBeanContext</code> je naplněn
        daty, která se dají použít k mnoha účelům. Jeho prostřednictvím má
        <span class="emphasis"><em>action bean</em></span> třída přístup k HTTP
        <span class="emphasis"><em>request</em></span> či <span class="emphasis"><em>response</em></span> objektu
        a tím i k HTTP <span class="emphasis"><em>sezení</em></span>. Obecně by měl být tento
        objekt centrálním vstupním bodem ke všem datům, která popisují, v
        jakém stavu se aplikace aktuálně nachází.</p><div class="sect3" lang="cs"><div class="titlepage"><div><div><h4 class="title"><a name="id413140"></a>Fáze životního cyklu požadavku</h4></div></div></div><p>Rámec Stripes má velmi dobře oddělené jednotlivé fáze
          zpracování HTTP požadavku. Od jeho příchodu ke
          <span class="emphasis"><em>controlleru</em></span> až po přesměrování na nějakou
          komponentu <span class="emphasis"><em>view</em></span>.</p><p>Při příchodu požadavku je rozlišováno těchto šest fází:</p><div class="orderedlist"><ol type="1"><li><p><span class="emphasis"><em>ActionBeanResolution</em></span> -- rámec v
              prvním kroku rozhodne, jakou <span class="emphasis"><em>action bean</em></span>
              instanci použije pro obsluhu požadavku a vytvoří instanci
              příslušné třídy.</p></li><li><p><span class="emphasis"><em>HandlerResolution</em></span> -- zde je zjištěna
              konkrétní <span class="emphasis"><em>akce</em></span>, která se vykoná, a určena
              metoda obslužné třídy, která tuto <span class="emphasis"><em>akci</em></span>
              reprezentuje.</p></li><li><p><span class="emphasis"><em>BindingAndValidation</em></span> -- ve třetí fázi
              se mapují parametry požadavku do jednotlivých atributů obslužné
              třídy a rovněž je provedena validace dat specifikovaná anotacemi
              (viz dále).</p></li><li><p><span class="emphasis"><em>CustomValidation</em></span> -- v dalším kroku je
              zavolána validační metoda, pokud vývojář tuto v <span class="emphasis"><em>action
              bean</em></span> instanci určil (bude vysvětleno dále).</p></li><li><p><span class="emphasis"><em>EventHandling</em></span> -- v této fázi je
              vykonána metoda, která byla vybrána ve druhém kroku k obsluze
              požadavku.</p></li><li><p><span class="emphasis"><em>ResolutionExecution</em></span> -- poslední krok
              je vykonán vždy, provádí se v něm předání požadavku na
              příslušnou komponentu <span class="emphasis"><em>view</em></span>. Ta je
              specifikována buď objektem typu
              <code class="classname">Resolution</code>, který vrátila provedená
              metoda <span class="emphasis"><em>akce</em></span>, nebo je jí <span class="emphasis"><em>zdrojová
              stránka</em></span>, pokud například selhala validace dat a
              uživatel má být přesměrován zpět na původní stránku pro jejich
              opětovné zadání.</p></li></ol></div><p>Ne všechny fáze jsou pro každý požadavek vykonány. Jak již
          bylo uvedeno, pokud se například vyskytnou validační chyby,
          požadavek je přesměrován na původní stránku (nejčastěji se znovu
          zobrazí formulář a v něm se vyznačí chybně zadaná data). Tím je
          například zcela vynechána pátá fáze.</p><p>Pomocí anotací lze také specifikovat, že pro danou
          <span class="emphasis"><em>akci</em></span> se má vynechat například fáze validace
          dat.</p><p>Autor jednotlivých <span class="emphasis"><em>action bean</em></span> instancí
          má jednoduchou možnost, jak nějaký úsek kódu vykonat přesně v daný
          okamžik, například <span class="emphasis"><em>před</em></span> či
          <span class="emphasis"><em>po</em></span> některé fázi zpracování požadavku. Toho lze
          docílit připojením anotace <code class="classname">@After</code> nebo
          <code class="classname">@Before</code> k libovolné metodě <span class="emphasis"><em>action
          bean</em></span> instance a specifikováním požadované fáze.</p><p>V dalších kapitolách si postupně rozebereme některé zajímavé
          fáze a popíšeme si jejich princip.</p></div><div class="sect3" lang="cs"><div class="titlepage"><div><div><h4 class="title"><a name="id413395"></a>Určení <span class="emphasis"><em>action bean</em></span> instance</h4></div></div></div><p>Stejně jako u <span class="emphasis"><em>Struts</em></span> či <span class="emphasis"><em>Spring
          Web MVC</em></span>, i pro <span class="emphasis"><em>Stripes</em></span> je nutno
          jednotlivé požadavky rozdělit podle nějakého kritéria a jejich
          obsluhu pak směrovat na jednotlivé <span class="emphasis"><em>action bean</em></span>
          instance. U těchto je možné deklarovat anotaci
          <code class="classname">@UrlBinding</code>, která vyžaduje pouze parametr
          <span class="emphasis"><em>value</em></span> typu <code class="classname">String</code>. Jeho
          obsahem je vzor <span class="emphasis"><em>absolutních</em></span> URL (vzhledem ke
          kontextu webové aplikace) jejichž požadavky bude třída obsluhovat.
          Anotace může tak vypadat třeba takto:</p><pre class="programlisting">@UrlBinding("/user.action")
public class UserActionBean implements ActionBean {
    ...
}</pre><p>Pokud je pro mapování požadavků použit nový
          <code class="classname">DynamicMappingFilter</code> (viz následující
          podkapitola <a href="#obsluha_pozadavku" title="Obsluha požadavků">„Obsluha požadavků“</a>), lze použít i
          složitější notaci:</p><pre class="programlisting">@UrlBinding("/user/{$event}/{user.id}")
public class UserActionBean implements ActionBean {
    ...
}</pre><p>Mezi složené závorky (<span class="emphasis"><em>{}</em></span>)je možné uvést
          názvy atributů, které mohou být součástí URL. Speciálním řetězcem je
          <span class="emphasis"><em>{$event}</em></span>, který bude nahrazen konkrétní
          <span class="emphasis"><em>akcí</em></span> vyvolanou v této třídě. Uvedený zápis tak
          znamená, že tato třída má obsluhovat URL
          <span class="emphasis"><em>/user/save/101</em></span>. Pro tuto URL pak bude vyvolána
          akce <span class="emphasis"><em>save</em></span> a do atributu <span class="emphasis"><em>id</em></span>
          atributu <span class="emphasis"><em>user</em></span> dané <span class="emphasis"><em>action
          bean</em></span> instance bude nastaveno číslo
          <span class="emphasis"><em>101</em></span>. Detailněji budou akce a automatické vázání
          parametrů rozebrány v následující podkapitolách <a href="#bean_actions" title="Volba vyvolané akce">„Volba vyvolané akce“</a> a <a href="#param_bind" title="Vázání parametrů z požadavku">„Vázání parametrů z požadavku“</a>. Více o
          podporovaném formátu anotace <code class="classname">@UrlBinding</code> lze
          najít v dokumentaci API uvedené jako zdroj v <a href="#bib_STRDOC">STRDOC</a>.</p><p>Korektní URL pro danou <span class="emphasis"><em>action bean</em></span>
          instanci jsou v JSP stránkách tvořeny pomocí dodávané knihovny
          značek, více viz podkapitola <a href="#stripes_taglib" title="Knihovna značek Stripes">„Knihovna značek Stripes“</a>.</p><p>Stripes tak vývojáři umožňuje velmi pohodlně používat hezké
          URL i pro obsluhu jednotlivých akcí. To je velmi výhodné pro SEO,
          jak bylo popsáno v podkapitole <a href="#friendly_urls" title="Tvorba hezkých URL">„Tvorba hezkých URL“</a>.</p></div><div class="sect3" lang="cs"><div class="titlepage"><div><div><h4 class="title"><a name="bean_actions"></a>Volba vyvolané akce</h4></div></div></div><p>Jak již bylo zmíněno, v rámci jedné <span class="emphasis"><em>action
          bean</em></span> instance je dále možné rozlišovat jednotlivé
          <span class="emphasis"><em>akce</em></span><a class="indexterm" name="id413650"></a>. Tyto jsou identifikovány svým
          <span class="emphasis"><em>názvem</em></span> a reprezentovány
          <span class="emphasis"><em>metodou</em></span>. Akcí může být libovolná
          <span class="emphasis"><em>veřejná</em></span> metoda, jejímž <span class="emphasis"><em>návratovým
          typem</em></span> je objekt implementující rozhraní
          <code class="classname">Resolution</code>. Tedy například:</p><pre class="programlisting">@HandlesEvent(name="save")
public Resolution saveUser() {
    ...

    return new ForwardResolution("/user-detail.jsp");
}</pre><p>Jak je v příkladu vidět, u této metody je specifikována
          anotace <code class="classname">@HandlesEvent</code>, která pojí tuto metodu
          s názvem <span class="emphasis"><em>akce</em></span>, kterou reprezentuje. Pokud by
          tato anotace nebyla uvedena, za název akce by byl brán název metody,
          tedy řetězec <span class="emphasis"><em>saveUser</em></span>. Toto automatické chování
          je další ukázkou principu
          <span class="emphasis"><em>convention-over-configuration</em></span>, uplatňovaným
          rámcem Stripes.</p><p>U jedné z metod reprezentujících akce může být uvedena anotace
          <code class="classname">@DefaultHandler</code>. Pokud pak požadavek na tuto
          <span class="emphasis"><em>action bean</em></span> instanci neobsahuje určení
          konkrétní <span class="emphasis"><em>akce</em></span>, která se má provést, je
          vykonána právě takto specifikovaná <span class="emphasis"><em>akce</em></span>.</p><p>Na návratové hodnotě uvedené metody je také vidět, jakým
          způsobem se po vykonání <span class="emphasis"><em>akce</em></span> předává řízení
          dále. V tomto případě je požadavek přesměrován na JSP stránku, která
          vypíše detaily aktuální uživatele a zobrazí informační zprávu, zda
          byly nové hodnoty uloženy. Rámec Stripes obsahuje několik
          implementací rozhraní <code class="classname">Resolution</code>, které
          pokrývají nejběžnější scénáře použití:</p><div class="itemizedlist"><ul type="disc"><li><p><code class="classname">ForwardResolution</code> -- přesměruje
              požadavek na danou URL;</p></li><li><p><code class="classname">RedirectResolution</code> -- přepošle
              požadavek na uvedenou adresu;</p></li><li><p><code class="classname">StreamingResolution</code> -- slouží k
              poskytnutí XML dat pro AJAX či pro generování dynamických
              obrázků;</p></li><li><p><code class="classname">ErrorResolution</code> -- vrátí jako
              výsledek HTTP chybu s daným kódem.</p></li></ul></div><p>Vývojář může rovněž využívat libovolnou vlastní implementaci
          rozhraní <code class="classname">Resolution</code>, pokud vyhodnotí její
          použití jako nejvhodnější.</p></div><div class="sect3" lang="cs"><div class="titlepage"><div><div><h4 class="title"><a name="param_bind"></a>Vázání parametrů z požadavku</h4></div></div></div><p>Velmi užitečným nástrojem, který rámec Stripes nabízí, je
          automatické vázaní parametrů požadavku<a class="indexterm" name="id413881"></a> do atributů <span class="emphasis"><em>action bean</em></span>
          instance. Typický případ může vypadat takto:</p><a name="prog_bind"></a><pre class="programlisting">public class User {
  private Long id;
  private String login;
  private String name;
  private BigDecimal interestRate;

  ... 
  // get and set methods for all attributes
}

public class UserActionBean implements ActionBean {
    
    private int count;
    public int getCount() { return this.count; }
    public void setCount(int count) { this.count = count; }

    private User user;
    public User getUser() { return this.user; }
    public void setUser(User user) { this.user = user; }

    ...
}</pre><p>Typ <code class="classname">User</code> musí být správně utvořený
          <span class="emphasis"><em>Java Bean</em></span>, tedy především mít
          <span class="emphasis"><em>bezparametrický konstruktor</em></span> a rovněž
          <span class="emphasis"><em>set</em></span> a <span class="emphasis"><em>get</em></span> metody pro
          všechny svoje atributy. Před zavoláním libovolné
          <span class="emphasis"><em>akce</em></span> provede rámec Stripes pokus o naplnění
          všech atributů dané <span class="emphasis"><em>action bean</em></span> instance (v
          našem příkladu tedy atributů <span class="emphasis"><em>user</em></span> a
          <span class="emphasis"><em>count</em></span>):</p><div class="itemizedlist"><ul type="disc"><li><p>pokud je typ atributu primitivní
              (<code class="classname">String</code>, <code class="classname">long</code>,
              <code class="classname">int</code>...):</p><div class="orderedlist"><ol type="1"><li><p>v HTTP požadavku se hledá parametr s názvem
                  odpovídajícím danému atributu, pokud je nalezen, nastaví se
                  jeho hodnota například následujícím způsobem:</p><pre class="programlisting">Integer count = Integer.valueOf(request.getParameter("count"));
bean.setCount(count);</pre></li></ol></div></li><li><p>pokud typ atributu není primitivní:</p><div class="orderedlist"><ol type="1"><li><p>inicializuje se daný atribut, tedy například se zavolá
                  metoda:</p><pre class="programlisting">bean.setUser(new User());</pre></li><li><p>v HTTP požadavku se hledají parametry, jejichž název
                  začíná názvem daného atributu, pro atribut
                  <span class="emphasis"><em>user</em></span> jsou tedy hledány parametry
                  <span class="emphasis"><em>user.id</em></span>, <span class="emphasis"><em>user.name</em></span>
                  a další;</p></li><li><p>pokud jsou tyto parametry nalezeny, pro každý se
                  spustí opakování celého tohoto postupu rekurzivně od
                  začátku.</p></li></ol></div></li></ul></div><p>Jak je z popsaného postupu vidět, rámec je schopných nastavit
          atributy <span class="emphasis"><em>action bean</em></span> instance i do hloubky,
          daný algoritmus je spuštěn rekurzivně na již nalezených
          atributech.</p><p>Rámec se taktéž stará o nezbytné přetypování hodnot
          jednotlivých parametrů (hodnoty HTTP parametrů jsou vždy typu
          <code class="classname">String</code>). Pomocí anotace lze rovněž určit
          konvertor, který bude pro převod parametru z typu
          <code class="classname">String</code> na objekt použit. Rámec obsahuje
          implementace více jak 15 konvertorů, například pro všechny
          primitivní typy jazyka Java, navíc třeba
          <code class="classname">DateTypeConverter</code>,
          <code class="classname">PercentageTypeConverter</code> či
          <code class="classname">EnumeratedTypeConverter</code>.</p><p>Vázání atributů z parametrů požadavku je velmi těsně spojeno s
          jejich <span class="emphasis"><em>validací</em></span>, dokonce se tyto dvě činnosti
          provádějí v rámci jedné fáze. Princip validace bude přiblížen v
          následující podkapitole.</p></div><div class="sect3" lang="cs"><div class="titlepage"><div><div><h4 class="title"><a name="id_phase_bindandvalid"></a>Validace dat</h4></div></div></div><p>Velmi užitečným nástrojem, který rámec Stripes nabízí, je
          validace formulářových dat<a class="indexterm" name="id414201"></a>. Největší odlišností od validačních systémů v rámcích
          <span class="emphasis"><em>Struts</em></span> či <span class="emphasis"><em>Spring Web MVC</em></span>
          je jeho <span class="emphasis"><em>deklarativní charakter</em></span>. A jistě nebude
          překvapením, že validaci dat lze nastavit pomocí anotací přímo v
          třídě <span class="emphasis"><em>action bean</em></span> instance.</p><p>Základním deklarativním nástrojem sloužícím k ověření
          integrity vložených dat je anotace <code class="classname">@Validate</code>.
          Ta slouží k ověření jedné konkrétní hodnoty. Ke specifikování
          souběžné validace pro více atributů stačí zahrnout danou množinu
          anotaci <code class="classname">@Validate</code> do jedné anotace
          <code class="classname">@ValidateNestedProperties</code> a tuto připojit v
          <span class="emphasis"><em>action bean</em></span> instanci před deklaraci atributu
          nebo jeho <span class="emphasis"><em>set</em></span> metody.</p><p>Pro nastavení konkrétního chování validace slouží jednotlivé
          atributy obsažené v anotaci <code class="classname">@Validate</code>,
          uvedeme si zde pouze ty nejpoužívanější:</p><div class="itemizedlist"><ul type="disc"><li><p><span class="emphasis"><em>field</em></span> -- název atributu, na který má
              být validace uplatněna;</p></li><li><p><span class="emphasis"><em>required</em></span> -- pokud má hodnotu
              <span class="emphasis"><em>true</em></span>, je nutné danou položku ve formuláři
              vyplnit;</p></li><li><p><span class="emphasis"><em>on</em></span> -- seznam názvů
              <span class="emphasis"><em>akcí</em></span>, při kterých bude validace provedena.
              Pokud je seznam prázdný nebo není pole u anotace uvedeno,
              provede se validace vždy;</p></li><li><p><span class="emphasis"><em>maxlength</em></span>,
              <span class="emphasis"><em>minlength</em></span> -- udává maximální (resp.
              minimální) povolenou délku vstupního řetězce;</p></li><li><p><span class="emphasis"><em>maxvalue</em></span>,
              <span class="emphasis"><em>minvalue</em></span> -- specifikuje maximální (resp.
              minimální) povolenou numerickou hodnotu daného atributu;</p></li><li><p><span class="emphasis"><em>expression</em></span> -- v tomto poli je možno
              uvést výraz jazyka <span class="emphasis"><em>Expression Language</em></span>,
              který bude pro daný atribut vyhodnocen;</p></li><li><p><span class="emphasis"><em>mask</em></span> -- zde je možno zadat
              <span class="emphasis"><em>regulární výraz</em></span>, kterému musí daný vstupní
              řetězec vyhovovat;</p></li><li><p><span class="emphasis"><em>converter</em></span> -- hodnotou tohoto pole lze
              určit, která třída má sloužit jako
              <span class="emphasis"><em>konvertor</em></span> z textového řetězce do
              objektu.</p></li></ul></div><p>Pro ilustraci aspoň části možností uvedeme jednoduchý příklad
          z praxe. Uvažme situaci, kdy chceme evidovat zákazníky banky. U
          každého zákazníka chceme uchovávat pouze jeho
          <span class="emphasis"><em>id</em></span>, <span class="emphasis"><em>login</em></span> pro přihlášení,
          <span class="emphasis"><em>celé jméno</em></span> a <span class="emphasis"><em>míru úroku</em></span>
          pro poskytnutí hypotéky -- viz ukázka kódu v předchozí kapitole
          <a href="#param_bind" title="Vázání parametrů z požadavku">„Vázání parametrů z požadavku“</a>. Příklad deklarativně zadané validace
          může vypadat například takto:</p><pre class="programlisting">public class UserActionBean implements ActionBean  {
  ...

  @ValidateNestedProperties(value={
    @Validate(field="id", required=false, minvalue=1),
    @Validate(field="login", required=true, minlength=5, 
        maxlength=12),
    @Validate(field="name", required=true, minlength=3, maxlength=100, 
        mask="\\w \\w"),
    @Validate(field="interestRate", on={"grantMortgage"}, required=true, 
        converter=PercentageTypeConverter.class)
    }
  )
  private User user;

  public User getUser() { return user; }
  public void setUser(User user) { this.user = user; }

  public Resolution grantMortgage() {
    ...
  }

  ...
}</pre><p>Pokud vývojář přesto zjistí, že dané anotace neposkytují
          dostatečnou sílu k provedení jeho validací, lze v <span class="emphasis"><em>action
          bean</em></span> instanci určit pomocí anotace
          <code class="classname">@ValidationMethod</code> libovolnou metodu, která
          bude automaticky rámcem zavolána k validaci dat. Tato metoda se vždy
          volá až po provedení všech deklarativně specifikovaných
          validací.</p></div></div><div class="sect2" lang="cs"><div class="titlepage"><div><div><h3 class="title"><a name="obsluha_pozadavku"></a>Obsluha požadavků</h3></div></div></div><p>Jediným nastavením, které je potřeba před používáním rámce
        provést, je deklarování servletu (respektive filtru), který bude
        jednotlivé HTTP požadavky mapovat na vývojářem vytvořené třídy --
        <span class="emphasis"><em>action bean</em></span> instance. Existují dvě možnosti, jak
        tuto konfiguraci<a class="indexterm" name="id414549"></a> provést.</p><div class="sect3" lang="cs"><div class="titlepage"><div><div><h4 class="title"><a name="id414566"></a>Statické mapování požadavků</h4></div></div></div><p>První možností je deklarovat servlet
          <code class="classname">StripesDispatcher</code> a filtr
          <code class="classname">StripesFilter</code>.</p><p><code class="classname">StripesFilter</code> při své inicializaci
          (která je spuštěna při nasazení aplikace do kontejneru) najde
          všechny obslužné třídy -- specifikované pomocí hodnoty
          inicializačního parametru
          <span class="emphasis"><em>ActionResolver.Packages</em></span> -- v dané webové
          aplikaci a shromáždí jejich konfiguraci poskytnutou formou anotací
          specifikovaných k kódu třídy.</p><p><code class="classname">StripesDispatcher</code> pak již podle
          dostupné konfigurace odbavuje jednotlivé HTTP požadavky a směruje je
          na jednotlivé přítomné <span class="emphasis"><em>action bean</em></span> instance
          podle URL, na kterou jsou mapovány.</p><p>Úplnou ilustraci tohoto případu konfigurace lze najít v
          podkapitole <a href="#dd" title="Deployment deskriptor">„Deployment deskriptor“</a> .</p></div><div class="sect3" lang="cs"><div class="titlepage"><div><div><h4 class="title"><a name="id414640"></a>Dynamické mapování pomocí
          <code class="classname">DynamicMappingFilter</code></h4></div></div></div><p>Druhým způsobem, jak korektní mapovaní URL zajistit, je
          deklarovat dva filtry. Tento způsob byl do rámce Stripes přidán ve
          verzi 1.5.</p><p>Prvním povinným filtrem je
          <code class="classname">StripesFilter</code>, jehož účel je shodný s
          předešlým případem. Druhým nezbytným úkonem je deklarování filtru
          <code class="classname">DynamicMappingFilter</code>, který plní stejnou
          funkci jako <code class="classname">StripesDispatcher</code>, avšak jinými
          prostředky.</p><p>Pro tento dynamický filtr také platí další dvě omezující
          podmínky, co se konfigurace týče:</p><div class="itemizedlist"><ul type="disc"><li><p>Tento filtr musí být mapován pomocí hodnoty
              <code class="classname">/*</code>, tedy musí být aplikován na
              <span class="emphasis"><em>veškeré</em></span> požadavky přicházející do webové
              aplikace.</p></li><li><p>Filtr musí být posledním aplikovaným filtrem. Pokud se mu
              totiž podaří úspěšně namapovat požadavek na některou action bean
              instanci, jakékoliv následné filtry jsou již ze zpracování
              požadavku vyřazeny.</p></li></ul></div><p>Úsek správné deklarace filtru
          <code class="classname">DynamicMappingFilter</code> v souboru
          <span class="emphasis"><em>web.xml</em></span> tak vypadá následovně:</p><pre class="programlisting">&lt;filter&gt;
  &lt;display-name&gt;Stripes Dynamic Mapping Filter&lt;/display-name&gt;
  &lt;filter-name&gt;DynamicMappingFilter&lt;/filter-name&gt;
  &lt;filter-class&gt;net.sourceforge.stripes.controller.DynamicMappingFilter
    &lt;/filter-class&gt;
&lt;/filter&gt;
 
&lt;filter-mapping&gt;
  &lt;filter-name&gt;DynamicMappingFilter&lt;/filter-name&gt;
  &lt;url-pattern&gt;/*&lt;/url-pattern&gt;
  &lt;dispatcher&gt;REQUEST&lt;/dispatcher&gt;
  &lt;dispatcher&gt;FORWARD&lt;/dispatcher&gt;
  &lt;dispatcher&gt;INCLUDE&lt;/dispatcher&gt;
&lt;/filter-mapping&gt;

&lt;!-- end of filters' declarations --&gt;</pre></div></div><div class="sect2" lang="cs"><div class="titlepage"><div><div><h3 class="title"><a name="stripes_taglib"></a>Knihovna značek Stripes</h3></div></div></div><p>Ačkoliv je možné jako komponentu <span class="emphasis"><em>view</em></span> rámce
        Stripes používat i <span class="emphasis"><em>Velocity</em></span> šablony, pohodlnější
        je pracovat s <span class="emphasis"><em>JSP</em></span>. Pro ně totiž vývojáři rámce
        Stripes připravili velmi užitečnou knihovnu značek<a class="indexterm" name="id414799"></a>.</p><p>Jednotlivé značky kompletně pokrývají funkcionalitu co se tvorby
        HTML formulářů týče, názvy elementů jsou pro snadné zapamatování
        shodné, pouze pocházejí z jiného jmenného prostotu a nabízejí
        deklaraci atributů pro konfiguraci chování v rámci Stripes.</p><p>Navíc tato knihovna obsahuje značky pro formování rozložení
        jednotlivých stránek či zobrazení informačních zpráv
        uživatelům.</p><p>Aby bylo v následujícím textu zřejmé, že daný element je z
        jmenného prostoru Stripes, bude vždy uváděn s prefixem
        <code class="classname">s</code>. Běžné HTML elementy budou uváděny bez
        prefixu.</p><div class="sect3" lang="cs"><div class="titlepage"><div><div><h4 class="title"><a name="id414854"></a>Značky pro tvorbu formulářů</h4></div></div></div><p>Základní značkou je <code class="classname">&lt;s:form&gt;</code>,
          která slouží, stejně jako její ekvivalent v HMTL, k ohraničení všech
          elementů, které obsahuje formulář. Ke správné obsluze formuláře je
          nutné zadat buď URL nějaké <span class="emphasis"><em>action bean</em></span>
          instance, nebo -- což je preferovaná volba -- vyplnit
          prostřednictvím atributu <span class="emphasis"><em>beanClass</em></span> plně
          kvalifikované jméno této instance, tedy název třídy včetně balíku.
          Knihovna značek pak správnou URL vyplní automaticky, například podle
          anotace <code class="classname">@UrlBinding</code> dané třídy.</p><p>Knihovna dále obsahuje ekvivalent všech známých ovládacích
          prvků jazyka HTML: <span class="emphasis"><em>textová pole</em></span>,
          <span class="emphasis"><em>drop-down menu</em></span>, <span class="emphasis"><em>zaškrtávací
          položky</em></span>, <span class="emphasis"><em>tlačítka</em></span> a další. Značky se
          však ve formuláři navíc zobrazují v závislosti na stavu aplikace.
          Například značka <code class="classname">&lt;s:text&gt;</code> (ekvivalent
          <code class="classname">&lt;input type="text"/&gt;</code>) zobrazí obsah
          atributu daného názvu příslušné <span class="emphasis"><em>action bean</em></span>
          instance, která je svázána z daným formulářem. Pokud byla zadána
          neplatná hodnota tohoto atributu, bude tato značka vykreslená s CSS
          třídou signalizující problém (například bude mít červené
          ohraničení).</p><p>Podle doporučení mnohých webových standardů by se k popiskám
          jednotlivých formulářových polí mělo využívat výhradně značky
          <code class="classname">&lt;label&gt;</code>, především z důvodu jednotnosti
          a přístupnosti i pro postižené uživatele. S tímto počítá i rámec
          Stripes a obsahuje ekvivalentní značku
          <code class="classname">&lt;s:label&gt;</code>, která vygeneruje nejen
          standardní HTML popisek, ale navíc se pokusí i vyhledat svůj vlastní
          text podle atributu <span class="emphasis"><em>for</em></span>, tedy podle
          identifikátoru atributu, pro který je popisek určen. Toto chování
          bude ilustrováno na příkladu uvedeném v následujících
          odstavcích.</p><p>Velmi užitečně rámec řeší generování drop-down seznamů (ukázka
          viz obrázek <a href="#pic_dropdown" title="Obrázek 3.1. Drop-down menu">3.1 – „Drop-down menu“</a>).</p><div class="figure"><a name="pic_dropdown"></a><p class="title"><b>Obrázek 3.1. Drop-down menu</b></p><div class="mediaobject"><table border="0" summary="manufactured viewport for HTML img" cellspacing="0" cellpadding="0" width="150"><tr><td><img src="images/drop-down-menu.png" width="150" alt="Drop-down menu"></td></tr></table></div></div><p>Pro vygenerování takového menu ve webovém prohlížeči je nutno
          vytvořit následující úsek HTML značkování:</p><pre class="programlisting">&lt;label for="color"&gt;Vaše oblíbená barva:&lt;/label&gt;
&lt;select name="colorId" id="color"&gt;
  &lt;option value="1"&gt;Červená&lt;/option&gt;
  &lt;option value="2"&gt;Modrá&lt;/option&gt;
  &lt;option value="3"&gt;Černá&lt;/option&gt;
  &lt;option value="4"&gt;Bílá&lt;/option&gt;
&lt;/select&gt;</pre><p>S knihovnou značek Stripes se stejného výsledku dosáhne pomocí
          značek <code class="classname">&lt;s:label&gt;</code>,
          <code class="classname">&lt;s:select&gt;</code> a
          <code class="classname">&lt;s:options-collection&gt;</code>:</p><pre class="programlisting">&lt;s:label for="color" name="color.id"/&gt;
&lt;s:select name="color.id" id="color"&gt;
  &lt;s:options-collection collection="${availableColors}" 
      value="id" label="name" /&gt;
&lt;/s:select&gt;</pre><p>Značka <code class="classname">&lt;s:label&gt;</code> nejprve dohledá
          svůj text podle atributu <span class="emphasis"><em>name</em></span> v
          <code class="classname">ResourceBundle</code> balíku rámce
          Stripes<sup>[<a href="#ftn.fn_stripesresources">16</a>]</sup>. Poté se
          vygeneruje daný ovládací prvek iterací přes prvky kolekce
          <span class="emphasis"><em>availableColors</em></span>. Pro každou položku se jako
          její hodnota, tedy obsah parametru <span class="emphasis"><em>color.id</em></span>
          odeslaný v požadavku po vyplnění formuláře, doplní hodnota atributu
          <span class="emphasis"><em>id</em></span> a jako textový popisek hodnota atributu
          <span class="emphasis"><em>name</em></span>.<sup>[<a name="fn_stripesresources" href="#ftn.fn_stripesresources">16</a>]</sup></p><p>Rámec obsahuje podobné značky i pro iteraci přes kolekci typu
          <code class="classname">Map</code> a výčet hodnot
          <code class="classname">Enum</code>. Pro vypsání seznamu položek tedy není
          nutné používat značku <code class="classname">&lt;c:forEach&gt;</code>
          zahrnutou v knihovně <span class="emphasis"><em>JSTL</em></span><sup>[<a href="#ftn.fn_JSTL">17</a>]</sup>, která slouží k iteraci přes libovolnou kolekci
          či pole hodnot.<sup>[<a name="fn_JSTL" href="#ftn.fn_JSTL">17</a>]</sup></p></div><div class="sect3" lang="cs"><div class="titlepage"><div><div><h4 class="title"><a name="id415258"></a>Ostatní značky</h4></div></div></div><p>Velmi užitečným nástrojem jsou značky vypisující informační
          případně chybové zprávy připojené k odpovědi na aktuální požadavek.
          O jejich zobrazení se stará dvojice značek <code class="classname">&lt;s:messages
          /&gt;</code> a <code class="classname">&lt;s:errors
          /&gt;</code>.</p><p>Zprávy se mohou na seznam k zobrazení dostat dvojím
          způsobem:</p><div class="itemizedlist"><ul type="disc"><li><p>Vloží je automaticky rámec, například pokud selže některá
              validace specifikovaná pomocí
              <code class="classname">@Validate</code>.</p></li><li><p>Jsou přidány v metodě obsluhující vyvolanou akci. Zprávy,
              jak informační tak chybové, jsou vždy přístupné přes kontext
              <span class="emphasis"><em>action bean</em></span> instance a přidat je lze tímto
              jednoduchým způsobem:</p><pre class="programlisting">getContext().getMessages().add(
  new LocalizableMessage("mortgage-granted", getUser().name));

getContext().getValidationErrors().addGlobalError(
  new LocalizableError("mortgage-not-granted", getUser().name));</pre><p>Zprávy musí být pod příslušnými klíči umístěny do
              <code class="classname">ResourceBundle</code> balíku rámce
              Stripes.</p></li></ul></div></div></div><div class="sect2" lang="cs"><div class="titlepage"><div><div><h3 class="title"><a name="id415355"></a>Možnosti tvorby šablon</h3></div></div></div><p>Často v aplikaci narazíme na problém, že jednotlivé JSP stránky
        jsou složeny z více částí (hlavička, menu, obsah, patička), z nichž
        některé zůstávají vždy stejné. Proto je výhodné využít nějaký systém
        šablon<a class="indexterm" name="id415369"></a>, který přidávání nových stránek oprostí od zbytečného
        kopírování již vytvořeného kódu.</p><p>Ve webové aplikaci spolupracující s rámcem Stripes lze k tomu
        účelu úspěšně využít značek
        <code class="classname">&lt;s:layout-definition&gt;</code>,
        <code class="classname">&lt;s:layout-render&gt;</code> a
        <code class="classname">&lt;s:layout-component&gt;</code>. K fungování není
        třeba žádný konfigurační soubor, i samotná šablona je pouhou JSP
        stránkou. Příklad jednoduché šablony může vypadat následovně:</p><pre class="programlisting">&lt;s:layout-definition&gt;
  &lt;!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" 
      "http://www.w3.org/TR/html4/loose.dtd"&gt;
  &lt;html&gt;
    &lt;head&gt;
      ...
    &lt;/head&gt;
  &lt;body&gt;
    &lt;div id="header"&gt;${pageName}&lt;/div&gt;
    &lt;div id="menu"&gt;
      &lt;ul&gt;
        ...
      &lt;/ul&gt;
    &lt;/div&gt;
    &lt;div id="content"&gt;
      &lt;s:layout-component name="content"/&gt;
    &lt;/div&gt;
    &lt;div id="footer"&gt;&amp;copy; Josef Sustacek&lt;/div&gt;
  &lt;/body&gt;
&lt;/html&gt;</pre><p>Pro použití této šablony pak stačí vytvořit novou JSP stránku a
        celý vypisovaný obsah zahrnout do těla značky
        <code class="classname">&lt;s:layout-render name="path"&gt;</code>, kde místo
        řetězce <span class="emphasis"><em>path</em></span> je uvedena absolutní cesta k souboru
        se šablonou (například
        <span class="emphasis"><em>/WEB-INF/layout/layout-definition.jsp</em></span>). Aby byl v
        šabloně správně nahrazen obsah jednotlivých částí, je nutné tento
        obsáhnout ve značkách tvaru:</p><pre class="programlisting">...
&lt;s:layout-component name="content"&gt;
  The content of first JSP page.
&lt;/s:layout-component&gt;
...</pre><p>V těle šablony je možno užívat pomocí <span class="emphasis"><em>Expression
        Language</em></span> odkazy na proměnné, které budou specifické pro
        každou stránku. V našem příkladu je to
        <span class="emphasis"><em>${pageName}</em></span>, čímž vkládáme do hlavičky název
        stránky. Při využití šablony je pak možné specifikovat libovolný počet
        atributů (ve značce <code class="classname">&lt;s:layout-render&gt;</code>),
        které jsou poté v těle šablony přístupné a vygenerují příslušnou
        hodnotu předanou při využití šablony.</p></div></div><div class="sect1" lang="cs"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="id415513"></a>Shrnutí konceptů a výhod užití</h2></div></div></div><p>Rámec Stripes bezesporu nemusí být pro každou webovou aplikaci
      nejvhodnějším řešením, přesto přichází z řadou konceptů, které jsou
      postupně přebírány i jinými webovými rámci. Mezi klíčové charakteristiky
      rámce patří tyto vlastnosti:</p><div class="itemizedlist"><ul type="disc"><li><p><span class="emphasis"><em>žádné konfigurační soubory</em></span> -- vše je
          konfigurováno pomocí nástrojů jazyka Java (především
          <span class="emphasis"><em>anotací</em></span>);</p></li><li><p><span class="emphasis"><em>convention-over-configuration</em></span> -- pokud
          není nějaká hodnota nastavení uvedena, je automaticky doplněna
          vhodná výchozí hodnota;</p></li><li><p><span class="emphasis"><em>návrh podporující rozšiřitelnost</em></span> --
          jestliže narazí vývojář na problém a rámec ho nedokáže vyřešit, má
          možnost naprogramovat vlastní rozšíření a instruovat rámec, aby ho
          využíval;</p></li><li><p><span class="emphasis"><em>projekt je živý</em></span> -- na projektu se stále
          pracuje, přibývá nová funkcionalita a opravují se chyby, aby byl
          rámec schopen držet krok s nejnovějšími technologiemi.</p></li></ul></div><p>Velmi dobrým zdrojem dalších informací jsou oficiální stránky
      projektu Stripes, které jsou odkazované v <a href="#bib_STRSITE">STRSITE</a>. Ty byly také použity jako hlavní pramen pro
      tuto kapitolu, vedle výukových materiálů pro předmět PA165 vyučovaný na
      Fakultě informatiky MU, viz <a href="#bib_STRIPESFI">STRIPESFI</a> .</p></div><div class="footnotes"><br><hr width="100" align="left"><div class="footnote"><p><sup>[<a name="ftn.fn_stripesresources" href="#fn_stripesresources">16</a>] </sup><code class="classname">ResourceBundle</code> balík rámce Stripes
              se podle Java standardu načítá ze souboru s názvem
              <span class="emphasis"><em>StripesResources.properties</em></span> umístěném v
              kořenovém balíku (<span class="emphasis"><em>default package</em></span>) webové
              aplikace. Pomocí přípon může obsahovat lokalizované klíče pro
              nejrůznější jazyky a státy. Více o práci s
              <code class="classname">ResourceBundle</code> lze nalézt v <a href="#bib_RBNDL">RBNDL</a>.</p></div><div class="footnote"><p><sup>[<a name="ftn.fn_JSTL" href="#fn_JSTL">17</a>] </sup>Knihovna <span class="emphasis"><em>JSTL</em></span> -- <span class="emphasis"><em>Java
              Server Pages Standard Tag Library</em></span> -- byla podrobněji
              přiblížena v předešlé kapitole v části <a href="#taglibs" title="Knihovny značek">„Knihovny značek“</a>.</p></div></div></div><div class="chapter" lang="cs"><div class="titlepage"><div><div><h2 class="title"><a name="netbeans_RCP"></a>Kapitola 4. NetBeans RCP</h2></div></div></div><p><span class="emphasis"><em>NetBeans Platform</em></span><a class="indexterm" name="id415649"></a> je generický rámec pro tvorbu desktopových aplikací v
    jazyce Java. Ve svém jádru používá mnoho konceptů a komponent základního
    nástroje pro tvorbu uživatelského rozhraní -- rámce
    <span class="emphasis"><em>Swing</em></span><a class="indexterm" name="id415675"></a>. Jeho hlavním záměrem je poskytnout vývojářům nových
    aplikací bohatou sadu již připravených nástrojů, které řeší funkcionalitu,
    jež musí být součástí každé desktopové aplikace. Mezi ty patří
    například:</p><div class="itemizedlist"><ul type="disc"><li><p>persistence stavu aplikace;</p></li><li><p>propojení položek v menu se spuštěním jednotlivých akcí;</p></li><li><p>konfigurovatelné nástrojové lišty;</p></li><li><p>správa klávesových zkratek;</p></li><li><p>jednotný přístup k nastavením celé aplikace;</p></li><li><p>správa jednotlivých oken aplikace a jejich částí.</p></li></ul></div><p>Vývojáři je také nabídnuta časem prověřená architektura, která je
    modulární a podporuje tak tvorbu a dynamické přidávání nových zásuvných
    modulů do již existující aplikace.</p><p>Zřejmě nejznámější aplikací založené na této platformě je
    <span class="emphasis"><em>NetBeans IDE</em></span>, komplexní vývojové prostředí pro
    nejrůznější programovací jazyky. Původně bylo uzpůsobeno především pro
    vývoj v jazyce Java, což zahrnovalo podporu jak pro standardní edici
    <span class="emphasis"><em>SE</em></span>, tak i <span class="emphasis"><em>ME</em></span> -- určenou pro
    mobilní telefony -- či <span class="emphasis"><em>EE</em></span>, zaměřenou na tvorbu
    rozsáhlých enterprise aplikací. Postupně však přibyla podpora i pro další
    programovací jazyky a v současné verzi NetBeans IDE 6.5 je možné tvořit
    aplikace v <span class="emphasis"><em>C/C++</em></span>, <span class="emphasis"><em>PHP</em></span>,
    <span class="emphasis"><em>JavaScriptu</em></span>, <span class="emphasis"><em>Ruby</em></span>,
    <span class="emphasis"><em>Groovy</em></span> či <span class="emphasis"><em>Pythonu</em></span>. Díky dobře
    navržené architektuře si každý vývojář může sestavit IDE přesně podle
    svých představ a zahrnout do něj pouze ty moduly, které bude využívat. Při
    změně zaměření není problém nepoužívané moduly odstranit a přidat
    libovolné nové.</p><p>Historie <span class="emphasis"><em>NetBeans</em></span> se začala psát roku 1997, kdy
    studenti MFF UK v Praze odstartovali práci na projektu
    <span class="emphasis"><em>Xelfi</em></span>. V následujících letech založili členové týmu
    společnost, která se zabývala tvorbou placené verze vývojového prostředí
    NetBeans IDE. S rokem 1999 přišla významná a pro další budoucnost
    <span class="emphasis"><em>NetBeans</em></span> klíčová událost -- veškerá práva koupila
    společnost Sun Microsystems. Tím dostal celý projekt možnost dále se
    rozvíjet pod křídly velké nadnárodní společnosti, která se na přelomu
    tisíciletí rozhodla distribuovat zdrojové kódy jako
    <span class="emphasis"><em>open-source</em></span> -- aktuálně pod licencí <span class="emphasis"><em>Common
    Development and Distribution License</em></span> (viz <a href="#bib_CDDL">CDDL</a>). Tím se také začala kolem projektu NetBeans
    formovat komunita, která je v současné době již velmi početná a společně s
    vývojáři firmy Sun se stará o stálý rozvoj celé platformy.</p><p>Srdcem konfigurace každého modulu je soubor
    <span class="emphasis"><em>layer.xml</em></span>. V tomto deskriptoru je specifikováno, zda
    modul zavádí nové typy souborů, přidává nové položky v menu, přináší další
    typy projektů, se kterým lze pracovat, a podobně.</p><p>Celý modul má po svém vytvoření formu jednoho souboru s příponou
    <span class="emphasis"><em>nbm</em></span> -- jde o běžný archiv vytvořený algoritmem
    <span class="emphasis"><em>ZIP</em></span>. Má přesně danou strukturu, obsahuje
    <span class="emphasis"><em>jar</em></span> archiv se všemi třídami vytvořenými v rámci
    modulu a v souboru <span class="emphasis"><em>MANIFEST.MF</em></span> pak reference na
    všechna NetBeans API použitá při tvorbě modulu.</p><p>NetBeans IDE poskytuje poměrně bohatou škálu nástrojů podporujících
    tvorbu nových modulů. Vývojář se tak může soustředit pouze na
    funkcionalitu samotného modulu a vývojové prostředí za něj zařídí správné
    vytvoření výsledného archivu i doplnění všech použitých referencí.</p><p>Popis celé platformy by vydal na několik diplomových prací, proto
    zde bude uveden pouze krátký popis těch API, která byla využita pro tvorbu
    zásuvného modulu, o kterém pojednává tato práce.</p><div class="sect1" lang="cs"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="id415968"></a>API použitá pro tvorbu nového modulu</h2></div></div></div><p>Pro tvorbu modulu bylo celkem využito služeb 23 aplikačních
      rozhraní<a class="indexterm" name="id415980"></a> z palety nabízené platformou NetBeans, následující seznam
      tedy není vyčerpávající. Obsahuje však všechny stěžejní komponenty a
      účel jejich využití při implementaci modulu.</p><div class="sect2" lang="cs"><div class="titlepage"><div><div><h3 class="title"><a name="id416004"></a>Nodes API</h3></div></div></div><p>Prvním rozhraním zmíněným ve výčtu je <span class="emphasis"><em>Nodes
        API</em></span>. Je základním stavebním kamenem jakékoliv aplikace
        založené na platformě NetBeans, protože se stará o vizualizaci
        veškerých objektů v aplikaci. Každý objekt je obalen jednotlivými
        <span class="emphasis"><em>aspekty</em></span> (vlastnostmi), které jsou poté užívány
        pro jejich zobrazení a dohromady tvoří <span class="emphasis"><em>uzel</em></span> --
        <span class="emphasis"><em>node</em></span>. Mezi ně patří například
        <span class="emphasis"><em>název</em></span>, <span class="emphasis"><em>zobrazený název</em></span>,
        <span class="emphasis"><em>sada nastavení</em></span>, <span class="emphasis"><em>hierarchie
        poduzlů</em></span> nebo sada souborů, které mají být použity jako
        <span class="emphasis"><em>ikony</em></span> reprezentující daný objekt v menu. Jakmile
        je pro nějaký objekt vytvořen jeho uzel, je možno začít tento objekt
        zobrazovat v nejrůznějších komponentách -- seznamech, stromech či
        tabulkách.</p><p>Architektura Nodes API je v mnohém rozšířením konceptu JavaBeans
        -- přidává do něj aspekty nezbytné pro pohodlné využívání uzlů v
        jednotlivých pohledech.</p><p>V implementovaném modulu je toto API používáno napříč celou
        architekturou. Jak již bylo řečeno, jde o stěžejní komponentu
        platformy NetBeans, bez které se neobejde téměř žádná aplikace
        vizualizující nějaké objekty.</p></div><div class="sect2" lang="cs"><div class="titlepage"><div><div><h3 class="title"><a name="id416100"></a>Filesystems API, Datasystems API</h3></div></div></div><p>Další dvě rozhraní spolu velmi úzce souvisí --
        <span class="emphasis"><em>Datasystems API</em></span> je postaveno nad
        <span class="emphasis"><em>Filesystems API</em></span>. Nejprve si tedy řekneme, k čemu
        slouží a co přináší Filesystems API a poté navážeme diskuzí, co vše
        lze získat prostřednictvím Datasystems API.</p><p><span class="emphasis"><em>Filesystems API</em></span> poskytuje jednotnou
        abstrakci nad libovolným souborovým systémem. Vývojář se nemusí starat
        o odlišnosti mezi jednotlivými specifikacemi a operačními systémy, k
        souboru vždy přistupuje přes jednotné rozhraní, ať jde o NTFS, EXT-3,
        ZFS či JAR archiv.</p><p>Základní třídou tohoto rozhraní je
        <code class="classname">FileObject</code>. Ten reprezentuje jeden objekt na
        disku -- buď soubor nebo složku. K daném objektu poskytuje
        odpovídající <code class="classname">FileObject</code> základní informace jako
        <span class="emphasis"><em>název</em></span>, <span class="emphasis"><em>rodičovský objekt</em></span> či
        informaci, zda objekt <span class="emphasis"><em>fyzicky existuje</em></span>. Dále tato
        třída zpřístupňuje esenciální operace potřebné k manipulaci s objekty
        -- přejmenování, smazání, přesunutí, kopírování a další.</p><p><span class="emphasis"><em>Datasystems API</em></span>, jak již bylo zmíněno,
        staví na předešlém rozhraní. Pomocí něj je možné každému objektu či
        složce přidat složitější logické atributy a provádět nad ním
        sofistikovanější operace -- například vytvoření souboru na základě
        šablony a poskytnutých parametrů, které jsou vyhodnoceny a vloženy do
        výsledného souboru.</p><p>Podobně jako v předchozím API i zde lze rozeznat jednu klíčovou
        třídu -- <code class="classname">DataObject</code>. Avšak již neplatí rovnost
        jako v případě Filesystems API, kde jeden soubor na disku
        reprezentoval vždy jeden <code class="classname">FileObject</code>. Jeden
        <code class="classname">DataObject</code> může reprezentovat i kolekci více
        instancí typu <code class="classname">FileObject</code>. Příkladem je
        například zdrojový soubor pro jazyk Java. Ten je vždy reprezentován
        jak textovým souborem s příponou <span class="emphasis"><em>.java</em></span>, tak
        souborem s příponou <span class="emphasis"><em>.class</em></span> obsahujícím přeložený
        byte kód. Pro každý jednotlivý <code class="classname">DataObject</code> však
        existuje vždy jednoznačně specifikovaný <span class="emphasis"><em>primární</em></span>
        <code class="classname">FileObject</code> -- v našem příkladě je jím textový
        soubor z příponou <span class="emphasis"><em>.java</em></span>.</p><p>Obě API jsou v modelu využívána pro veškeré operace se soubory
        -- například čtení obsahu deployment deskriptoru, již zmíněné
        vytváření souborů že šablon či hledání zdrojových souborů vytvořených
        vývojářem v daném projektu.</p></div><div class="sect2" lang="cs"><div class="titlepage"><div><div><h3 class="title"><a name="id416282"></a>Window System API</h3></div></div></div><p>Každá desktopová aplikace, která má grafické rozhraní, se skládá
        z jednoho či více oken. O jejich správu se v prostředí platformy
        NetBeans stará <span class="emphasis"><em>Window System API</em></span>.</p><p>Celé rozhraní je vystavěno nad třídou
        <code class="classname">TopComponent</code>, která je rozšířením jedné z
        komponent rámce <span class="emphasis"><em>Swing</em></span> -- třídy
        <code class="classname">JComponent</code>. Reprezentuje vizuální jednotku,
        která může být v NetBeans zobrazena a lze v ní vizualizovat nějaká
        data. Takovou komponentou může být například celé okno aplikace či ji
        může reprezentovat jedna záložka tvořící součást jiného okna. Nad
        instancí třídy <code class="classname">TopComponent</code> může uživatel
        provádět operace, které jsou typické pro mnoho aplikací s grafickým
        uživatelským rozhraním -- jednotlivé komponenty lze minimalizovat,
        maximalizovat nebo zakotvit uvnitř jiné komponenty.</p><p>O správu oken se stará vždy implementace třídy
        <code class="classname">WindowManager</code>. Především se automaticky stará o
        persistenci stavu všech oken aplikace. Pokud uživatel ukončí běh
        aplikace, uloží se nejen obsah všech oken (například v editoru), ale
        také rozložení jednotlivých komponent. Zajímavou funkcionalitou je
        asociace rozložení oken podle typu souboru, který je otevřen v
        editoru. Je zřejmé, že k pohodlné editaci JSP souboru je vhodné mít k
        dispozici zcela jiné ovládací prvky, něž pro psaní zdrojového kódu v
        jazyce Java. Správce oken si složení a rozložení sady oken pamatuje a
        při otevření souboru stejného typu zobrazí ta okna, která uživatel k
        editaci stejného typu souboru použil naposled, a umístí je na stejná
        místa, kde je uživatel zanechal. Toto chování je velmi podobné
        <span class="emphasis"><em>perspektivám</em></span> známým z vývojového prostředí
        <span class="emphasis"><em>Eclipse</em></span>.</p><p>Toto API není v modulu využíváno explicitně, nebylo třeba
        vytvářet nové typy oken či s nimi asociovat speciální akce. Jeho
        využití je však nezbytné vzhledem ke grafickému rozhraní celého
        NetBeans IDE.</p></div><div class="sect2" lang="cs"><div class="titlepage"><div><div><h3 class="title"><a name="id416408"></a>Web APIs, J2EE DD API</h3></div></div></div><p>Dostáváme se k rozhraním, která jsou využívána především u
        modulů, které rozšiřují možnosti při tvorbě webových aplikací.</p><p>První sada API usnadňuje práci s webovými moduly obecně --
        zpřístupňuje jejich nastavení a definuje pro ně užitečné konstanty.
        Architekti platformy NetBeans mysleli na možné rozšiřování IDE o
        nejrůznější webové rámce. Toto rozhraní tak například obsahuje metody
        pro získání seznamu registrovaných rámců a v SPI<sup>[<a href="#ftn.fn_SPI">18</a>]</sup> části pak přímo i třídy užívané při tvorbě modulu
        přidávajícího do IDE podporu pro webový rámec.<sup>[<a name="fn_SPI" href="#ftn.fn_SPI">18</a>]</sup></p><p>Základem celého API je abstraktní třída
        <code class="classname">WebFrameworkProvider</code>, která reprezentuje jeden
        webový rámec v rámci platformy. Prostřednictvím instance této třídy
        lze získat řadu informací: seznam konfiguračních souborů, se kterými
        rámec pracuje, jaké knihovny se mají k projektu připojit, pokud chce
        vývojář webový rámec využívat, či jaké nastavení je třeba v projektu
        (webové aplikaci) provést, aby rámec po nasazení do kontejneru správně
        pracoval. Instance této třídy musí být korektně zaregistrována v
        souboru <span class="emphasis"><em>layer.xml</em></span> pod klíčem
        <span class="emphasis"><em>j2ee/webtier/framework</em></span>.</p><p>Druhé rozhraní -- <span class="emphasis"><em>J2EE DD API</em></span> -- je
        využíváno ke čtení a zápisu <span class="emphasis"><em>deployment
        deskriptoru</em></span> webové aplikace. Jak již bylo zmíněno, pokud
        vývojář má zájem o využívání rámce Stripes ve webové aplikaci, musí
        provést některá nutná nastavení v souboru
        <span class="emphasis"><em>web.xml</em></span>. Modul, jehož návrhem a implementací se
        zabývá tato diplomová práce, provede všechna nezbytná nastavení
        automaticky. Soubor se však nezpracovává jako textový soubor ani se
        neanalyzuje pomocí XML parseru. <span class="emphasis"><em>J2EE DD API</em></span>
        poskytuje třídy a metody k pohodlné práci s deskriptorem, přidání
        nezbytných servletů a filtrů je pak otázkou pouze několika řádků
        kódu.</p></div><div class="sect2" lang="cs"><div class="titlepage"><div><div><h3 class="title"><a name="id416550"></a>Project API, Project UI API, Java Project Support</h3></div></div></div><p><span class="emphasis"><em>Project API </em></span>je základem pro jakoukoliv
        práci s <span class="emphasis"><em>projekty</em></span> v prostředí platformy NetBeans.
        Toto API definuje abstrakci nad projekty jako kolekcemi souborů, které
        mají danou strukturu, je možné je kompilovat a jinak s nimi
        manipulovat. V NetBeans se standardně k sestavování projektů používá
        nástroj <span class="emphasis"><em>Ant</em></span>, jsou však i moduly podporující
        tvorbu a práci s projekty sestavovanými pomocí nástroje
        <span class="emphasis"><em>Maven</em></span> či <span class="emphasis"><em>make</em></span>.</p><p>Z tohoto rozhraní bylo využíváno především třídy
        <code class="classname">FileOwnerQuery</code>, pomocí níž lze určit projekt,
        ve kterém je obsažen daný soubor (určený pomocí instance
        <code class="classname">FileObject</code>). Také bylo hojně využíváno možností
        třídy <span class="emphasis"><em>ProjectUtils</em></span>, která umožňuje získat všechny
        skupiny zdrojových souborů (kolekci instancí implementujících rozhraní
        <code class="classname">SourceGroup</code>) vytvořených v daném projektu. Toho
        bylo využito v nejrůznějších oknech, které reflektují aktuální
        strukturu zdrojových souborů v projektu. Příkladem může být dialog, ve
        kterém vývojář vybírá šablonu rozložení pro novou JSP stránku.</p><p>Další dvě rozhraní obsahují implementaci typicky používaných
        grafických komponent, které jsou využívány v souvislosti s projekty
        aplikací založených na platformě Java.</p><p>Příkladem může být dialog pro vytvoření nového Java souboru,
        který lze získat prostřednictvím třídy
        <code class="classname">JavaTemplates</code>. Obsahuje standardní pole pro
        volbu názvu souboru a balíku, ve kterém má být nový zdrojový soubor
        umístěn. Komponenta může být navíc rozšířena o panel obsahující
        ovládací prvky pro zadání dalších údajů, které jsou poté použity k
        vytvoření souboru. Tohoto dialogu bylo využito při implementaci tvorby
        nové <span class="emphasis"><em>action bean</em></span> instance. Jde to běžnou třídu,
        vývojář má však navíc možnost při vytváření nové <span class="emphasis"><em>action
        bean</em></span> instance specifikovat předka třídy (jiný, dříve
        vytvořený <span class="emphasis"><em>action bean</em></span>), či zda mají být
        implementovány / překryty metody pro získání a nastavení
        kontextu.</p></div><div class="sect2" lang="cs"><div class="titlepage"><div><div><h3 class="title"><a name="lexer_api"></a>Lexer API</h3></div></div></div><p>Toto rozhraní, jak již jeho název napovídá, definuje přístup k
        lexikografické analýze nějakého textu. Zdrojem textu může být
        například <code class="classname">CharSequence</code>,
        <code class="classname">java.io.Reader</code> nebo
        <code class="classname">javax.swing.text.Document</code>.</p><p>Klíčovým prvkem celého API je rozhraní
        <code class="classname">TokenId</code>. Každá instance toho rozhraní pak
        reprezentuje jeden <span class="emphasis"><em>token</em></span> v daném jazyce.
        Jednotlivé jazyky (například Java, JSP, HTML atd.) implementují
        rozhraní <code class="classname">TokenId</code> -- nejčastěji ve formě
        výčtového typu (potomka abstraktní třídy
        <code class="classname">java.lang.Enum</code>). Výčet pak zahrnuje veškeré
        lexikografické jednotky daného jazyka: <span class="emphasis"><em>rezervovaná
        slova</em></span>, <span class="emphasis"><em>identifikátory</em></span>,
        <span class="emphasis"><em>literály</em></span>, <span class="emphasis"><em>oddělovače</em></span>,
        <span class="emphasis"><em>operátory</em></span> atd.</p><p>Pro účely tvorby nového modulu byly využity následující dvě
        implementace rozhraní Lexer:</p><div class="itemizedlist"><ul type="disc"><li><p><span class="emphasis"><em>Java Lexer</em></span>;</p></li><li><p><span class="emphasis"><em>HTML Lexer</em></span>.</p></li></ul></div><p>Obě implementace byly použity pro možnost tvorby hypertextových
        odkazů mezi jednotlivými zdrojovými soubory. Vždy je nejprve nutné
        určit, zda daná oblast textu, ve které vývojář chce aktivovat
        hypertextový odkaz, má jako odkaz sloužit. Například v JSP souboru je
        podle umístění kurzoru v textu určeno, zda se tento nachází uvnitř
        hodnoty atributu <span class="emphasis"><em>beanClass</em></span> nějaké značky Stripes.
        Pokud ano, je celá hodnota tohoto atributu zobrazena jako odkaz a po
        kliknutí na něj se provede pokus o otevření Java souboru
        specifikovaného daným plně kvalifikovaným jménem (balík a název
        třídy).</p></div><div class="sect2" lang="cs"><div class="titlepage"><div><div><h3 class="title"><a name="id416826"></a>Editor API, Text API</h3></div></div></div><p>Poslední dvě rozhraní, která budou ve výčtu zmíněna, pokrývají v
        NetBeans potřebu na otevírání souborů v editoru a možnost změny jejich
        obsahu, například na základě uživatelem provedené akce.</p><p><span class="emphasis"><em>Editor API</em></span> slouží k přidávání různých
        editorů, které jsou vždy vázány na určité typy souborů. Pro každý typ
        souboru (XML dokument, zdrojový soubor Java, JSP, soubor CSS pravidel)
        je vhodné mít k dispozici specializovaný editor, který tvorbu
        příslušného dokumentu co nejvíce usnadní. V NetBeans IDE jsou k
        dispozici editory pro nejrůznější jazyky, v nichž je samozřejmostí
        barevné zvýrazňování klíčových slov, odsazování nových řádků,
        doplňování konce rozepsané části slova v závislosti na kontextu
        (<span class="emphasis"><em>code-completion</em></span>) a další.</p><p>Pokud tvůrce nového modulu zavede nový typ souboru (například
        přidává podporu pro nový programovací jazyk, jež dosud není v NetBeans
        IDE zahrnut), může pro něj rovněž definovat nový typ editoru. Ten je
        pak automaticky vybrán pro otevření nového typu souboru. Pokud pro
        daný typ souboru neexistuje žádný specializovaný editor, použije se
        editor prostého textu.</p><p><span class="emphasis"><em>Text API</em></span> přináší možnosti, jak textový
        obsah daného dokumentu (otevřeného v nějakém editoru) číst a
        programově měnit. Zajímavou možností tohoto rozhraní je schopnost
        <span class="emphasis"><em>zamknout</em></span> určitou část zdrojového kódu tak, že jej
        uživatel nemůže prostřednictvím NetBeans editoru nijak změnit. To je
        velmi vhodné, pokud je například tato část kódu automaticky generována
        a uživatelovy změny v této oblasti by byly dříve či později nahrazeny
        vygenerovaným textem.</p><p>Kombinace možností, které obě API nabízejí, bylo využito při
        tvorbě nových položek pro <span class="emphasis"><em>paletu</em></span>. Ta slouží ke
        vkládání krátkých úseků kódu, například HTML značek. Z okna palety
        stačí přetáhnout myší příslušnou značku přímo do okna editoru a ta se
        automaticky vloží na určené místo v kódu. API bylo použito ke zjištění
        pozice kurzoru a vložení kódu nové značky do již existujícího
        textu.</p></div></div><div class="footnotes"><br><hr width="100" align="left"><div class="footnote"><p><sup>[<a name="ftn.fn_SPI" href="#fn_SPI">18</a>] </sup>SPI je zkratka slov <span class="emphasis"><em>Service Provider
            Interface</em></span>. Na rozdíl od API -- <span class="emphasis"><em>Application
            Programming Interface</em></span> -- to není sada rozhraní, nýbrž
            abstraktních tříd, které sice obsahují nějakou funkcionalitu, ale
            musí být pro konkrétní nasazení vývojářem doplněny o další
            chování.</p></div></div></div><div class="chapter" lang="cs"><div class="titlepage"><div><div><h2 class="title"><a name="impl"></a>Kapitola 5. Implementace zásuvného modulu</h2></div></div></div><p>Nový modul si klade za cíl usnadnit vývoj webových aplikací, které
    jsou založeny na rámci Stripes<a class="indexterm" name="id416950"></a>. Na rozdíl od ostatních webových rámců (Struts, Spring Web
    MVC, Wicket, JSF) neexistovala pro tento rámec v prostředí NetBeans IDE
    žádná speciální podpora. To samozřejmě nevylučovalo vývoj aplikace
    operující prostřednictvím tohoto rámce, nicméně oproti vývoji aplikace
    využívají některý z podporovaným rámců to vyžadovalo od vývojáře větší
    počáteční investici, co se znalostí týče.</p><p>V první podkapitole budou shrnuty rysy, které jsou do vývojového
    prostředí díky novému modulu přidány. Zároveň budou uvedeny názorné
    ukázky, jak tyto nové aspekty zjednodušují vývoj nové webové
    aplikace.</p><p>V další podkapitole si přiblížíme nástroje a postupy, pomocí nichž
    byl projekt řízen a které napomáhaly k úspěšnému naplnění jeho cílů. Mezi
    ně patří sběr požadavků, správa verzí, sledovaní změn, publikování nových
    verzí a další. Již delší dobu se ukazuje, že tyto činnosti jsou daleko
    důležitější, než samotná tvorba (kódování) celé aplikace a jejich
    opomenutí má často za následek neúspěch celého projektu.</p><p>V poslední, třetí podkapitole budou diskutovány některé z problémů,
    které musely být při implementaci modulu řešeny, a způsob, jakým byly
    překonány.</p><div class="sect1" lang="cs"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="id417009"></a>Implementovaná funkcionalita</h2></div></div></div><p>V této podkapitole, jak již její název napovídá, bude probrána
      šíře záběru nového modulu, tedy jaké podpůrné nástroje přidává do
      NetBeans IDE a jak tyto vývojáři mohou usnadnit vývoj.</p><p>Sběr požadavků byl proveden na základě dvou hlavních zdrojů.
      Prvním byly osobní zkušenosti při vývoji několika projektů, ve kterých
      se na prezentační vrstvě používal rámec Stripes. Druhým byly již
      existující zásuvné moduly, které v NetBeans IDE existují, například pro
      Struts, Spring Web MVC nebo Wicket.</p><p>Kořenovým balíkem byl po vzoru konvencí v prostředí platformy
      NetBeans a ostatních webových modulů zvolen
      <code class="classname">org.netbeans.modules.web.stripes</code>.</p><div class="sect2" lang="cs"><div class="titlepage"><div><div><h3 class="title"><a name="id417054"></a>Registrace rámce v projektu</h3></div></div></div><p>Základním požadavkem na funkčnost nového modulu bylo vytvoření
        stejných startovních podmínek, jako mají jiné webové rámce. Tedy dát
        vývojáři nové webové aplikace možnost zvolit si podporu pro rámec
        Stripes na stejném místě, jako byl zvyklý u jiných rámců. Tímto bodem
        je v NetBeans IDE průvodce pro vytvoření nového projektu webové
        aplikace. Průvodce má několik částí a jedna z nich dává možnost přidat
        podporu pro některý z dostupných webových rámců. Proto bylo více než
        vhodné zahrnout přidání rámce Stripes právě do seznamu nabídnutém při
        vytvoření nového projektu.</p><p>Nový webový rámec lze do zmíněného seznamu zahrnout
        zaregistrováním instance v souboru <span class="emphasis"><em>layer.xml</em></span> pod
        klíčem <span class="emphasis"><em>j2ee/webtier/framework</em></span>. Tato instance musí
        rozšiřovat třídu <code class="classname">WebFrameworkProvider</code>, dané
        kritérium splňuje v modulu nově vytvořená třída nazvaná
        <code class="classname">StripesWebFrameworkProvider</code>, která implementuje
        všechny povinné abstraktní metody svého předka. V architektuře
        NetBeans IDE reprezentuje každá instance třídy
        <code class="classname">WebFrameworkProvider</code> obálku, která zaštiťuje
        jeden webový rámec. Jejím prostřednictvím lze získat název daného
        rámce, jeho popis, množinu konfiguračních souborů užívaných rámcem a
        mimo jiné i implementaci třídy
        <code class="classname">WebModuleExtender</code>, pomocí níž je webová
        aplikace fyzicky rozšířena o podporu nějakého rámce. Pro tyto účely
        byla vytvořena třída <code class="classname">StripesWebModuleExtender</code>,
        která implementuje především tyto dvě metody:</p><pre class="programlisting">abstract JComponent getComponent();
abstract Set&lt;FileObject&gt; extend(WebModule webModule);</pre><p>První metodu zavolá průvodce vytvořením nového projektu v
        okamžiku, kdy potřebuje zobrazit konfigurační dialog daného rámce.
        Druhá metoda je průvodcem vyvolána, pokud vývojář daný webový rámec
        zahrne do své aplikace a ta se tak rozšíří o jeho podporu. Kontrakt
        této metody říká, že návratovou hodnotou je kolekce souborů, které
        mají být po úspěšném vytvoření projektu otevřeny v editoru vývojového
        prostředí. Metoda <span class="emphasis"><em>extend()</em></span> má možnost získat
        nastavení provedená v konfiguračním dialogu, její chování tedy může
        být naprogramováno v závislosti na provedených nastaveních.</p><p>Třetí stěžejní třída, která byla vytvořena pro potřeby
        konfigurace rámce Stripes v projektu webové aplikace, nese název
        <code class="classname">StripesConfigPanel</code>. Je potomkem třídy
        <code class="classname">JPanel</code> z rámce Swing, jde o grafický panel
        zobrazující ovládací prvky pro konfiguraci rámce. Instance této třídy
        je návratovou hodnotou metody <span class="emphasis"><em>getComponent()</em></span>. Pro
        ilustraci, jak tento konfigurační dialog vypadá v průvodci vytvořením
        nového projektu, může sloužit obrázek <a href="#pic_config_dialog" title="Obrázek 5.1. Konfigurační dialog">5.1 – „Konfigurační dialog“</a>.</p><div class="figure"><a name="pic_config_dialog"></a><p class="title"><b>Obrázek 5.1. Konfigurační dialog</b></p><div class="mediaobject"><table border="0" summary="manufactured viewport for HTML img" cellspacing="0" cellpadding="0" width="463"><tr><td><img src="images/new-project-wizard.png" width="463" alt="Konfigurační dialog"></td></tr></table></div></div><p>Dialog má tři záložky, v první lze nastavit parametry pro
        Stripes Dispatcher a Filter, jejichž význam byl popsán v kapitole
        <a href="#stripes" title="Kapitola 3. Rámec Stripes">3 – „<i>Rámec Stripes</i>“</a>. Uživatel si v současné verzi modulu nemůže
        zvolit v konfiguračním dialogu obsluhu požadavků pomocí dynamického
        filtru. To je způsobeno faktem, že v době tvorby modulu nebyla k
        dispozici stabilní verze Stripes verze 1.5 (vydána až v průběhu března
        2009), ale pouze 1.4.3, ve které se tato funkcionalita nevyskytovala.
        Možnost zvolit dynamické mapování by měla být zcela určitě přidána v
        některé z dalších verzí modulu, například ve formě drop-down menu v
        první záložce dialogu. Vložená data -- tedy obsah dvou textových polí
        -- jsou při každé změně automaticky validována pomocí regulárního
        výrazu. Uživateli se tak nepodaří vložit neplatný vstup -- například
        prázdný řetězec znaků.</p><p>Druhá záložka poskytuje možnosti zvolit, zda k projektu přidat
        <code class="classname">ResourceBundle</code>, ze kterého Stripes budou brát
        lokalizované zprávy pro názvy polí, validační chyby apod. Také je
        možné nastavit, jaké lokalizace zahrnout (aktuálně je dostupná
        anglická a česká), a která lokalizace bude pro rámec v dané aplikaci
        výchozí. Třetí a momentálně poslední záložka konfiguračního dialogu
        slouží k přidání dodatečných knihoven -- vedle standardních .jar
        archivů nezbytných pro běh rámce v aplikaci. Momentálně je možné
        využít automatického připojení knihovny značek JSTL verze 1.2.</p><p>Pokud tvůrce nového projektu zvolil podporu rámce Stripes ve své
        aplikaci, zavolá se metoda <span class="emphasis"><em>extend()</em></span>. Ta provede
        <span class="emphasis"><em>atomicky</em></span> následující sekvenci akcí:</p><div class="itemizedlist"><ul type="disc"><li><p>změní se obsah deployment deskriptoru tvořené webové
            aplikace -- vytvoří se servlet a filtr pro Stripes a dle
            konfiguračního dialogu se namapují na dané URL;</p></li><li><p>k aplikaci se připojí knihovny rámce Stripes případně i
            jakékoliv další vybrané v třetí záložce konfiguračního
            dialogu;</p></li><li><p>pokud uživatel zvolil přidání lokalizovaných souborů, podle
            zadaného nastavení se tyto vytvoří na korektním místě (kořenový
            balík zdrojových souborů Java) a naplní správným obsahem.</p></li></ul></div><p>Všechny třídy vytvořené pro správnou funkčnost této části modulu
        jsou umístěné pro přehlednost v podbalíku
        <code class="classname">config</code>.</p></div><div class="sect2" lang="cs"><div class="titlepage"><div><div><h3 class="title"><a name="new_templates"></a>Nové šablony souborů</h3></div></div></div><p>Platforma NetBeans umožňuje definovat šablony souborů, ze
        kterých lze generovat výsledné instance. V šablonách lze používat
        syntaxi jazyka <span class="emphasis"><em>Freemarker</em></span> a využívat proměnných,
        které jsou při vytvoření každého souboru k dispozici. Těmi jsou
        například <span class="emphasis"><em>název</em></span> nového souboru či jeho
        <span class="emphasis"><em>autor</em></span>. V šabloně je tak lze nahradit zástupnými
        symboly <span class="emphasis"><em>${user}</em></span> respektive
        <span class="emphasis"><em>${name}</em></span>, které jsou při vytvoření výsledného
        souboru nahrazeny korektními hodnotami platnými pro nový
        soubor.</p><p>Vývojář, který tvoří aplikaci stavějící na podpoře rámce
        Stripes, nejčastěji vytváří tři druhy souborů související s rámcem.
        Prvním typem jsou <span class="emphasis"><em>action bean</em></span> instance, tedy
        zdrojové soubory tříd pro obsluhu požadavků. Druhým jsou Stripes
        šablony sloužící k definování rozložení JSP stránek a posledním JSP
        soubory užívající jako základ svého rozložení některou z dříve
        vytvořených šablon knihovny Stripes.</p><p>Modul přidává šablony pro všechny tři jmenované typy souborů. Ke
        každé šabloně je možné v prostředí platformy NetBeans rovněž
        zaregistrovat průvodce (konfigurační dialog zobrazený při vytváření
        nového souboru ze šablony), který může obsahovat další nastavení
        specifické pro daný typ souboru. Specializovaný průvodce byl vytvořen
        pro novou JSP stránku založenou na šabloně rozložení a pro nový action
        bean. První průvodce umožňuje zadat cestu k použité Stripes šabloně či
        tuto vybrat pomocí dialogu, jak ilustruje obrázek <a href="#pic_stripes_templete_usage_wizard" title="Obrázek 5.2. Průvodce vytvořením JSP obsahující využití šablony
          rozložení">5.2 – „Průvodce vytvořením JSP obsahující využití šablony
          rozložení“</a>. Pro vytvoření šablony
        rozložení nebyl specifikován speciální průvodce, je tedy použit
        standardní, který je v NetBeans IDE používán k vytváření běžných JSP
        souborů.</p><div class="figure"><a name="pic_stripes_templete_usage_wizard"></a><p class="title"><b>Obrázek 5.2. Průvodce vytvořením JSP obsahující využití šablony
          rozložení</b></p><div class="mediaobject"><table border="0" summary="manufactured viewport for HTML img" cellspacing="0" cellpadding="0" width="463"><tr><td><img src="images/new-template-usage-wizard.png" width="463" alt="Průvodce vytvořením JSP obsahující využití šablony rozložení"></td></tr></table></div></div><p>Průvodce, který je uživateli zobrazen, pokud chce vytvořit novou
        <span class="emphasis"><em>action bean</em></span> instanci, má složitější chování.
        Umožňuje zadat následující parametry výsledného souboru Java:</p><div class="itemizedlist"><ul type="disc"><li><p>zda bude vytvořená třída implementovat / překrývat metody
            <span class="emphasis"><em>getContext()</em></span> a
            <span class="emphasis"><em>setContext()</em></span>, případně jaká třída se má
            použít jako implementace kontextu (pokud má třída předka, nemusejí
            se tyto již generovat, pokud jsou implementovány a pro použití
            nové třídy vyhovují);</p></li><li><p>zda bude třída mít nějakého předka (například jinou action
            bean instanci);</p></li><li><p>možnost přidat anotaci <code class="classname">@UrlBinding</code> a
            specifikovat vzor URL, kterou bude třída obsluhovat.</p></li></ul></div><p>Předka i třídu kontextu je možné zadat buď vyplněním jejího plně
        kvalifikovaného jména (název souboru a balík, ve kterém je umístěna),
        či ji vybrat mezi existujícími zdroji v projektu. Vzhled průvodce je
        zachycen na obrázku <a href="#pic_action_bean_wizard" title="Obrázek 5.3. Průvodce vytvořením nové action bean
          instance">5.3 – „Průvodce vytvořením nové <span class="emphasis"><em>action bean</em></span>
          instance“</a>.</p><div class="figure"><a name="pic_action_bean_wizard"></a><p class="title"><b>Obrázek 5.3. Průvodce vytvořením nové <span class="emphasis"><em>action bean</em></span>
          instance</b></p><div class="mediaobject"><table border="0" summary="manufactured viewport for HTML img" cellspacing="0" cellpadding="0" width="500"><tr><td><img src="images/new-action-bean-wizard.png" width="500" alt="Průvodce vytvořením nové action bean instance"></td></tr></table></div></div><p>Prostředí NetBeans IDE poskytuje jednoduchý nástroj, jak
        sdružovat šablony nejrůznějších zdrojových souborů. V menu
        <span class="emphasis"><em>Tools</em></span> -&gt; <span class="emphasis"><em>Templates</em></span> je
        budována struktura typu les, do které jsou umísťovány jednotlivé
        šablony. Kolekci dostupných šablon lze obohatit buď přidáním nového
        modulu, který nějaké šablony definuje, či vytvořením šablony z
        existujícího souboru. Zároveň je možné libovolnou existují šablonu
        přímo v IDE změnit. Pokud tedy vývojáři webové aplikace nevyhovuje
        formát generovaného souboru (například preferuje jiné pořadí polí
        generovaných ve výsledné třídě nebo si přeje vkládat do hlavičky
        vlastní licenci), může si danou šablonu upravit přesně k obrazu svému.
        Při jejím příštím využití již bude vygenerovaný soubor odpovídat
        provedeným změnám.</p><p>Veškeré šablony musejí být registrovány v souboru layer.xml
        příslušného modulu, pod klíčem <span class="emphasis"><em>Templates</em></span>. Šablony
        je možné dále organizovat do složek, aby se na jednom místě nacházely
        vždy šablony jednoho zaměření. Bylo tak více než rozumné zařadit
        všechny tři vytvořené šablony do společné složky a jsou tedy
        definované pod klíčem <span class="emphasis"><em>Templates/Stripes</em></span>. Tím je
        zabezpečeno, že vývojář při vytvoření nového souboru najde šablony
        týkající se rámce Stripes vždy v jedné složce pojmenované Stripes,
        která je vždy umístěna na stejném místě mezi ostatními složkami
        šablon.</p></div><div class="sect2" lang="cs"><div class="titlepage"><div><div><h3 class="title"><a name="id409842"></a>Nové položky JSP palety</h3></div></div></div><p>Platforma NetBeans má mnoho užitečných nástrojů pro editaci
        souborů. Vedle samotných editorů, kterých může být nepřeberné množství
        a mohou se lišit dle druhu souboru, existuje i nástroj zvaný
        <span class="emphasis"><em>paleta</em></span>. Nejčastěji má formu dialogového okna,
        které se nachází vpravo od editovaného textu. Na paletu je možné
        umísťovat jednotlivé položky, které reprezentují krátké úseky kódu,
        které je možné poté umísťovat do editovaného kódu. Princip je velmi
        podobný <span class="emphasis"><em>šablonám</em></span>, které byly probrány v předešlé
        podkapitole <a href="#new_templates" title="Nové šablony souborů">„Nové šablony souborů“</a>, nově vytvořeným objektem
        však není celý soubor, nýbrž pouze krátký úsek textu. Shodným rysem je
        i možnost definovat dialog s nastavením, který je zobrazen před
        vložením dané položky a může ovlivnit výsledný vložený text.</p><p>Obsah palety se mění v závislosti na typu souboru, který je
        otevřen v editoru. Vývojář tak uvidí zcela jiné položky, když bude
        editovat HTML soubor, než když si otevře například JSP stránku.
        Položky lze do palety přidat opět buď nainstalováním nového modulu,
        který nějaké položky palety definuje, či přes <span class="emphasis"><em>Správce
        palety</em></span>. Pomocí něj lze rovněž měnit pořadí existujících
        položek či je z palety zcela odstranit. Jednotlivé položky lze
        seskupovat do složek, podobně jako šablony souborů.</p><p>Modul rámce Stripes přidává do palety celkem tři složky --
        značky <span class="emphasis"><em>pro tvorbu formulářů</em></span>, značky
        <span class="emphasis"><em>definující rozložení stránky</em></span> a <span class="emphasis"><em>ostatní
        značky</em></span> knihovny Stripes. Všechny jsou definovány v souboru
        layer.xml pod klíčem, který odpovídá <span class="emphasis"><em>druhu
        palety</em></span>, do kterého mají být jednotlivé položky přidány.
        Všechny nově vytvořené položky vkládají do textu některou ze značek
        knihovny Stripes. Jejich vložení je relevantní pouze pro JSP soubory,
        položky jsou tedy registrovány pod klíčem
        <span class="emphasis"><em>JSPPalette</em></span>, což zajistí jejich zobrazování pouze
        pokud je editována nějaká JSP stránka.</p><p>Každá položka palety má svůj vlastní <span class="emphasis"><em>XML
        deskriptor</em></span>. Ten je registrován v konfiguračním souboru
        <span class="emphasis"><em>layer.xml</em></span> a obsahuje definici těchto atributů
        dané položky:</p><div class="itemizedlist"><ul type="disc"><li><p>která třída reprezentuje chování dané položky palety;</p></li><li><p>jaké ikony mají být v paletě použity pro vizualizaci položky
            (vedle jejího názvu);</p></li><li><p>jaký <code class="classname">ResourceBundle</code> se má použít pro
            načtení lokalizovaných popisků jednotlivých položek.</p></li></ul></div><p>Třída která definuje danou položku musí implementovat rozhraní
        <code class="classname">ActiveEditorDrop</code>. To obsahuje pouze jednu
        metodu, která je zavolána, pokud uživatel umístí nějakou položku
        palety do okna editoru. Její deklarace je následovná:</p><pre class="programlisting">public boolean handleTransfer(JTextComponent targetComponent);</pre><p>Do palety je novým modulem přidáno celkem více jak 20 položek.
        Chování při vložení položky je více méně stejné pro každou položku, po
        jejím umístění do okna editoru je provedena následující sekvence
        úkonů:</p><div class="orderedlist"><ol type="1"><li><p>pokud byl pro položku definován konfigurační dialog, je
            tento zobrazen;</p></li><li><p>pokud uživatel nastavení v dialogu potvrdil (stiskl tlačítko
            <span class="emphasis"><em>OK</em></span>), je zahájena změna obsahu souboru
            otevřeného v editoru;</p></li><li><p>do souboru je na zvolené místo vložen definovaný kus kódu,
            případně upravený podle nastavení vyplněných v dialogu.</p></li></ol></div><p>Z tohoto důvody byla navržena objektová struktura pro jednotlivé
        položky palety, aby se využilo znovupoužitelnosti jednotlivých částí
        procesu. Byla vytvořena abstraktní třída
        <code class="classname">CodeSnippet</code>, která reprezentuje jednu položku
        palety, a která implementuje zmíněné rozhraní
        <code class="classname">ActiveEditorDrop</code>. Třída obsahuje tři abstraktní
        metody, které musejí být u konkrétní položky implementovány:</p><pre class="programlisting">protected abstract String createBody(int caretPositionOnLine);

protected abstract CodeSnippetCustomizer getCustomizer(
        CodeSnippet snippet, JTextComponent target);
    
protected abstract String getBundleKey();</pre><p>První metoda vrací textový řetězec, který má být vložen do těla
        editovaného dokumentu. Kontrakt druhé metody říká, že vrátí instanci
        konfiguračního dialogu (viz dále), pokud položka tento využívá,
        případně prázdný odkaz (<span class="emphasis"><em>null</em></span>). Poslední metoda
        vrátí jedinečný klíč, který identifikuje danou položku a je využíván k
        načítání lokalizovaných řetězců dané položky.</p><p>Dále byla přidána abstraktní třída
        <code class="classname">CodeSnippetCustomizer</code>, která rozšiřuje
        <code class="classname">JPanel</code> a slouží jako objekt reprezentující
        konfigurační dialog dané položky palety. Obsahuje jedinou abstraktní
        metodu -- <span class="emphasis"><em>evaluateInput()</em></span>. Ta je zavolána při
        potvrzení dialogu (stisku tlačítka OK) a jejím úkolem je předání
        vyplněných nastavení instanci třídy
        <code class="classname">CodeSnippet</code>, pomocí které byl daný dialog
        vyvolán. Pro jednotlivé položky palety, u kterých je žádoucí
        konfigurační dialog, je pak vytvořena implementace -- například
        <code class="classname">ButtonCustomizer</code>. Instance této třídy je pak
        vrácena metodou <span class="emphasis"><em>getCustomizer()</em></span> příslušné třídy
        reprezentující danou položku palety --
        <code class="classname">Button</code>.</p><p>Jak již bylo zmíněno, každá položka má definovány dvě ikony,
        které jsou zobrazovány vedle jejího názvu v paletě. Některé nové
        položky palety -- zvláště ty, které vkládají značky týkající se
        formulářů -- mají své ekvivalenty v jazyce HTML. Tyto mají v NetBeans
        své položky v paletě zobrazované při editaci HTML souborů. Pro část
        položek tedy byly použity ikony již přítomné v NetBeans. Zhruba
        polovina značek knihovny Stripes však nemá svůj předobraz v žádném
        značkovacím jazyce a pro jejich položky v paletě musely být vytvořeny
        ikony nové. Pro jejich tvorbu se jako velmi užitečným ukázal být
        nástroj <span class="emphasis"><em>Inkscape</em></span>. Jde o zdarma šířený grafický
        software, pomocí nějž lze tvořit a upravovat vektorové obrázky ve
        formátu SVG. Pro všechny položky, kterým dosud chyběla ikona, byl tak
        vytvořen vektorový obrázek znázorňující sémantiku dané položky. Z něj
        pak byly vygenerovány bitmapové verze o velikosti 16x16 a 32x32, které
        jsou požadováný platformou NetBeans. Výsledné ikony byly poté umístěny
        do modulu a použity v deskriptoru dané položky jako malá respektive
        velká ikona.</p><p>Všechny vytvořené třídy, XML deskriptory a ikony jsou umístěny v
        balíku <code class="classname">palette</code>, respektive jeho podúrovních.
        Pro ilustraci vzhledu palety a rozsahu vytvořených položek může
        sloužit obrázek <a href="#pic_palette" title="Obrázek 5.4. Paleta s položkami pro rámec Stripes">5.4 – „Paleta s položkami pro rámec Stripes“</a>.</p><div class="figure"><a name="pic_palette"></a><p class="title"><b>Obrázek 5.4. Paleta s položkami pro rámec Stripes</b></p><div class="mediaobject"><table border="0" summary="manufactured viewport for HTML img" cellspacing="0" cellpadding="0" width="500"><tr><td><img src="images/palette.png" width="500" alt="Paleta s položkami pro rámec Stripes"></td></tr></table></div></div><p></p></div><div class="sect2" lang="cs"><div class="titlepage"><div><div><h3 class="title"><a name="new_features"></a>Hypertextové odkazy</h3></div></div></div><p>Velmi užitečným rysem, který platforma NetBeans nabízí, je
        možnost tvorby aktivních odkazů mezi jednotlivými zdrojovými soubory.
        Tyto jsou velmi podobně odkazům, které lze tvořit v jazyce HTML pomocí
        značky <code class="classname">&lt;a&gt;</code>. Každý úsek editovaného kódu
        může sloužit jako odkaz, v NetBeans je standardně aktivován podržením
        klávesy <span class="emphasis"><em>Ctrl</em></span> a přejetím myši nad textem. Pokud
        pro dané místo zdrojového souboru má být aktivován odkaz, je tento
        zvýrazněn podtržením aktivního textu nebo změnou jeho barvy. Pokud na
        tento odkaz uživatel klikne levým tlačítkem myši, je provedena
        definovaná akce -- nejčastěji otevření odkazovaného souboru v editoru.
        Zároveň je možné v cílovém souboru specifikovat i určité místo, na
        kterém je po otevření souboru umístěn kurzor.</p><p>Celé NetBeans IDE je plné aktivních odkazů, zvláště pro Java
        soubory či JSP stránky. Pro ukázku si vezměme ukázku Java kódu na
        obrázku <a href="#pic_java_hyperlinks" title="Obrázek 5.5. Ukázka aktivních odkazů v jazyce Java">5.5 – „Ukázka aktivních odkazů v jazyce Java“</a>. V tomto krátkém úseku
        kódu je k dispozici celkem 6 aktivním odkazů. Aktivním jsou všechny
        uvedené typy (v tomto případě třikrát třída
        <code class="classname">String</code> a anotace
        <code class="classname">@Override</code>), po jejich aktivování je otevřen
        příslušný zdrojový soubor z knihovny standardních tříd jazyka Java.
        Aktivování řetězce <span class="emphasis"><em>prefix</em></span> na 60. řádku přenese
        kurzor na 58. řádek, tedy na místo, kde byla proměnná deklarována.
        Podobně je kurzor přemístěn i po aktivování odkazu nad statickou
        proměnnou <span class="emphasis"><em>BUNDLE_KEY</em></span> použitou v těle uvedené
        metody.</p><div class="figure"><a name="pic_java_hyperlinks"></a><p class="title"><b>Obrázek 5.5. Ukázka aktivních odkazů v jazyce Java</b></p><div class="mediaobject"><table border="0" summary="manufactured viewport for HTML img" cellspacing="0" cellpadding="0" width="400"><tr><td><img src="images/java_hyperlinks.png" width="400" alt="Ukázka aktivních odkazů v jazyce Java"></td></tr></table></div></div><p>V případě rámce Stripes bylo vytvoření podpory aktivních odkazů
        nasnadě. Často jsou z JSP stránek odkazovány jednotlivé action bean
        instance, například jako obslužné třídy pro formuláře či ve značce
        <code class="classname">&lt;s:url&gt;</code> sloužící k vytvoření URL, pomocí
        niž lze zavolat danou událost v dané action bean instanci. V
        jednotlivých metodách action bean instancí je řízení často předáváno
        na některou JSP stránku, udanou jako parametr konstruktoru příslušného
        objektu typu <code class="classname">Resolution</code>, který je poté vrácen
        obslužnou metodou. Užití obou typů odkazů ilustrují obrázky <a href="#pic_hyperlink_from_jsp" title="Obrázek 5.6. Aktivní odkaz vedoucí z JSP na action
          bean instanci">5.6 – „Aktivní odkaz vedoucí z JSP na <span class="emphasis"><em>action
          bean</em></span> instanci“</a> a <a href="#pic_hyperlink_from_bean" title="Obrázek 5.7. Aktivní odkaz směřující z action bean instance na danou JSP
          stránku">5.7 – „Aktivní odkaz směřující z action bean instance na danou JSP
          stránku“</a>.</p><div class="figure"><a name="pic_hyperlink_from_jsp"></a><p class="title"><b>Obrázek 5.6. Aktivní odkaz vedoucí z JSP na <span class="emphasis"><em>action
          bean</em></span> instanci</b></p><div class="mediaobject"><table border="0" summary="manufactured viewport for HTML img" cellspacing="0" cellpadding="0" width="488"><tr><td><img src="images/link_from_jsp.png" width="488" alt="Aktivní odkaz vedoucí z JSP na action bean instanci"></td></tr></table></div></div><div class="figure"><a name="pic_hyperlink_from_bean"></a><p class="title"><b>Obrázek 5.7. Aktivní odkaz směřující z action bean instance na danou JSP
          stránku</b></p><div class="mediaobject"><table border="0" summary="manufactured viewport for HTML img" cellspacing="0" cellpadding="0" width="463"><tr><td><img src="images/link_from_bean.png" width="463" alt="Aktivní odkaz směřující z action bean instance na danou JSP stránku"></td></tr></table></div></div><p>K přidání podpory pro nový typ odkazů musí být v daném modulu
        vytvořena třída, která implementuje rozhraní
        <code class="classname">HyperlinkProvider</code>, a tato musí být korektně
        zaregistrována v souboru <span class="emphasis"><em>layer.xml</em></span>. Použitým
        klíčem je <span class="emphasis"><em>Editors/text/x-jsp/HyperlinkProviders</em></span>
        pro nové odkazy ze souborů JSP respektive
        <span class="emphasis"><em>Editors/text/x-java/HyperlinkProviders</em></span> pro odkazy
        ze souborů Java (<span class="emphasis"><em>action bean </em></span>instancí). Rozhraní
        <code class="classname">HyperlinkProvider</code> obsahuje tři metody, které je
        nutno implementovat:</p><pre class="programlisting">boolean isHyperlinkPoint(Document doc, int offset);

int[] getHyperlinkSpan(Document doc, int offset);
          
void performClickAction(Document doc, int offset);</pre><p>První je automaticky zavolána, pokud se v editoru nachází daný
        dokument a je v něm aktivován odkaz. Má-li dané místo sloužit jako
        aktivní odkaz, vrátí metoda hodnotu <span class="emphasis"><em>true</em></span>. Druhá
        vrátí v případě nutnosti aktivovat odkaz počátek a konec textu, který
        má být jako odkaz zobrazen. A konečně třetí metoda je zavolána v
        případě, že uživatel na aktivovaný odkaz klikne levým tlačítkem
        myši.</p><p>Pro přidání zmíněné funkčnosti byly vytvořeny dvě třídy:</p><div class="itemizedlist"><ul type="disc"><li><p><code class="classname">StripesBeanClassHyperlinkProvider</code> pro
            odkazy z action bean instancí;</p></li><li><p><code class="classname">StripesActionBeanToJspHyperlinkProvider</code>
            k přidání odkazů směřujících z JSP stránek obsahujících značky
            Stripes.</p></li></ul></div><p>Tyto byly registrovány v souboru <span class="emphasis"><em>layer.xml</em></span>.
        K implementaci metod <span class="emphasis"><em>isHyperlinkPoint()</em></span> a
        <span class="emphasis"><em>getHyperlinkSpan()</em></span> rozhraní
        <code class="classname">HyperlinkProvider</code> bylo využito Lexer API, jak
        již bylo zmíněno v předešlé části <a href="#lexer_api" title="Lexer API">„Lexer API“</a>.
        Aktivní odkazy jsou v souboru JSP aktivovány u všech značek, které
        mají atribut <span class="emphasis"><em>beanClass</em></span>. Jeho hodnotou je plně
        kvalifikovaný název action bean instance. Druhý druh odkazů je
        aktivován v případě, kdy se kurzor nachází na prvním parametru
        konstruktoru jednoho z typů <code class="classname">ForwardResolution</code>,
        <code class="classname">OnwardResolution</code> či
        <code class="classname">RedirectResolution</code>. Prvním parametrem je vždy
        textový řetězec, který určuje název souboru, na který se má předat
        řízení. Pokud je tímto parametrem literál typu
        <code class="classname">String</code> (tedy například řetězec
        <span class="emphasis"><em>/WEB-INF/jsp/user-detail.jsp</em></span> uzavřený do
        uvozovek), může uživatel přejít přímo na soubor daného jména.</p></div></div><div class="sect1" lang="cs"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="id418974"></a>Použité nástroje a postupy</h2></div></div></div><p>V této podkapitole budou popsány postupy a nástroje, které byly
      použity k úspěšnému splnění vytyčených cílů. Mezi ně nepatří pouze
      nástroje použité přímo k tvorbě kódu, ale také prvky projektového řízení
      vývoje.</p><div class="sect2" lang="cs"><div class="titlepage"><div><div><h3 class="title"><a name="id418994"></a>NetBeans IDE</h3></div></div></div><p>Základním nástrojem použitým k implementaci nového modulu je
        <span class="emphasis"><em>NetBeans IDE</em></span><a class="indexterm" name="id419008"></a>. Jedná se o standardní vývojové prostředí pro tvorbu
        aplikací, které je založeno na platformě NetBeans. A mimo jiné také
        obsahuje typ projektu <span class="emphasis"><em>Modul pro platformu
        NetBeans</em></span>. Bylo tedy logické a nejjednodušší odstartovat
        práci na modulu právě vytvořením projektu tohoto typu. NetBeans IDE
        poté poskytuje vývojáři mnoho užitečných prostředků k obohacování
        modulu novou funkcionalitou. Především je to několik průvodců pro
        vytvoření typický prvků aplikace -- například nové <span class="emphasis"><em>položky v
        menu</em></span>, nového <span class="emphasis"><em>typu souboru</em></span> či nové
        položky v <span class="emphasis"><em>nastavení aplikace</em></span>. Průvodce vytvoří
        všechny nezbytné třídy a konfiguraci v souboru
        <span class="emphasis"><em>layer.xml</em></span>, což ve výsledku implementuje
        požadovanou funkcionalitu.</p><p>Kolekce průvodců ovšem nepokrývá veškeré možnosti platformy
        NetBeans, ani požadavky na novou funkcionalitu, jak byla popsána v
        předešlé podkapitole <a href="#new_features" title="Hypertextové odkazy">„Hypertextové odkazy“</a>. Ta byla v
        takovém případě vytvořena na základě některého z výukových cvičení
        (viz <a href="#bib_NBTUT">NBTUT</a>) a postupně obohacována a
        optimalizována pro pokrytí všech potřeb.</p><p>NetBeans IDE také umožňuje jednotlivé moduly testovat a ladit.
        Modul je možné spustit v nové instanci NetBeans, do zdrojového kódu
        lze umísťovat místa přerušení (<span class="emphasis"><em>breakpoints</em></span>) a
        poté chod aplikace krokovat jako jakoukoliv jinou aplikaci. Velmi
        efektivní možností je schopnost platformy zavádět nové moduly za běhu
        aplikace, tedy bez nutnosti jejího restartu -- tzv.
        <span class="emphasis"><em>hot-deploy</em></span>. To otevírá možnosti k rapidnímu
        zkrácení iterační cyklu, kdy vývojář během několika málo sekund může
        vidět či otestovat efekt jím přidaného kódu v běžící aplikaci.</p></div><div class="sect2" lang="cs"><div class="titlepage"><div><div><h3 class="title"><a name="id419137"></a>Řízení projektu</h3></div></div></div><p>Základními pilíři pro úspěšné dokončení projektu<a class="indexterm" name="id419148"></a> jsou v zásadě tyto tři nástroje:</p><div class="itemizedlist"><ul type="disc"><li><p><span class="emphasis"><em>systém pro správu verzí</em></span>;</p></li><li><p><span class="emphasis"><em>nástroj pro sledování změn</em></span>, jejich
            správu a kategorizování;</p></li><li><p><span class="emphasis"><em>veřejně přístupná webová prezentace</em></span>,
            která shrnuje cíle a stav vývoje celého projektu.</p></li></ul></div><p>Po krátkém pátrání na internetu byl jako nejvhodnější kandidát
        na pokrytí všech požadavků zvolen systém <span class="emphasis"><em>Google
        Code</em></span><sup>[<a href="#ftn.fn_googlecode">19</a>]</sup><a class="indexterm" name="id419223"></a>. Systém nabízí prostor pro uchování zdrojových souborů
        v <span class="emphasis"><em>repositáři Subversion</em></span><a class="indexterm" name="id419240"></a> s veřejným přístupem z jakéhokoliv místa. Zároveň je
        přístup autentizován a probíhá přes zabezpečený protokol HTTPS.
        Dostupný prostor pro zdrojové soubory má aktuálně velikost 1024 MB na
        jeden projekt, což vytváří dostatečnou volnost v tvorbě jakékoliv
        struktury a obsahu repositáře. Dále je možné využívat jednoduchý
        <span class="emphasis"><em>systém na sledování změn</em></span>. Registrovaní uživatelé
        tak mohou vkládat požadavky na novou funkcionalitu (či nalezené
        defekty) a poté sledovat, zda byl návrh přijat a v jakém stadium je
        jeho implementace (respektive oprava). Třetí bod, tedy možnost
        prezentovat cíle projektu, splňuje jednoduchá
        <span class="emphasis"><em>wiki</em></span><sup>[<a href="#ftn.fn_wiki">20</a>]</sup><a class="indexterm" name="id419287"></a>, kterou lze obohacovat libovolnými informacemi
        vztahujícími se k projektu.<sup>[<a name="fn_googlecode" href="#ftn.fn_googlecode">19</a>]</sup><sup>[<a name="fn_wiki" href="#ftn.fn_wiki">20</a>]</sup></p><p>Systém také obsahuje stránku, na kterou lze umístit soubory ke
        stažení, tedy například binární distribuce vytvořené sestavením určité
        verze zdrojových souborů. To je velmi užitečné pro koncové uživatele,
        kteří se nechtějí starat o zdrojové soubory a zajímá je pouze
        výsledek, tedy sestavený modul připravený k instalaci do jejich
        systému.</p><p>V prvních fázích projektu byl celý systém využívám především
        autorem celého modulu, v první řadě ke sběru požadavků a nastavování
        jejich priorit. Postupně byla rozšiřována wiki s popisem jednotlivých
        rysů nového modulu a také umísťovány sestavené binární distribuce
        jednotlivých verzí modulu. V pozdějších fázích začali do systému
        rovněž přispívat jednotliví uživatelé modulu, především pak promítali
        do systému své návrhy na zlepšení a chyby nalezené při používání
        modulu ve svých vývojových prostředích.</p></div><div class="sect2" lang="cs"><div class="titlepage"><div><div><h3 class="title"><a name="id419408"></a>Publikování nových verzí modulu</h3></div></div></div><p>Celý modul byl vyvíjen iterativně, implementovaná funkcionalita
        tedy přibývala postupně v jednotlivých cyklech. Tím vznikl požadavek
        jak, nové verze modulu poskytnout uživatelům novým či těm, kteří již
        mají nainstalovanou některou z předchozích verzí modulu.</p><p>NetBeans IDE obsahuje ve standardní edici správce modulů, pomocí
        nějž lze přidávat, odebírat či měnit instalaci jednotlivých částí
        NetBeans IDE. Vývojáři tedy stačí poskytnout ke stažení binární soubor
        obsahující daný modul, uživatel si archiv uloží na svůj lokální disk a
        poté je možné (po spuštění NetBeans IDE ) nový modul nainstalovat.
        Pokud se v systému modul již nachází, avšak jeho verze je starší než
        ta specifikovaná v nově staženém archivu, je provedeno odstranění
        starší verze a její nahrazení modulem novým.</p><p>Pro realizování popsaného postupu tak zpočátku vyhovovaly
        možnosti nabízené aplikací Google Code. Po přidaní nové funkcionality
        a jejím otestování byla pomocí NetBeans IDE vytvořena binární
        distribuce a tato prostřednictvím formuláře nahrána na server. Od té
        chvíle měli všichni návštěvníci webových stránek projektu tuto verzi k
        dispozici.</p><p>Postupem času, v přibývajícími verzemi, přestalo být řešení
        dostačující. Stereotypní posloupnost jednotlivých manuálních akcí tak
        byla nahrazena automatizovaným procesem. K realizaci přenosu nového
        archivu na server bylo využito služeb zásuvného modulu z projektu
        <span class="emphasis"><em>ant-googlecode</em></span> (viz <a href="#bib_GCUP">GCUP</a>).
        Ten umožňuje pomocí nástroje Ant (který je standardním nástrojem pro
        sestavování všech projektů v prostředí NetBeans IDE) nahrát libovolný
        soubor na zvolené místo na serveru Google Code. V deklaraci daného
        úkolu pro nástroj Ant stačí uvést platné údaje -- název projektu,
        přihlašovací jméno, heslo a popis souboru -- a daný archiv je
        automaticky umístěn na server.</p><p>Zvolený postup byl velkým přínosem pro zefektivnění práce, avšak
        pouze ze strany vývojáře. Uživatelé modulu museli nové verze stále
        manuálně stahovat ze stránek projektu a instalovat do svých NetBeans.
        Platforma NetBeans naštěstí nabízí možnost, jak zautomatizovat i
        proces přenosu nové verze modulu ke všem uživatelům, kteří ho mají
        nainstalovaný. Slouží k tomu <span class="emphasis"><em>NetBeans Update
        Center</em></span><a class="indexterm" name="id419511"></a>.</p><p>Do libovolné aplikace založené na platformě NetBeans je možné
        registrovat jedno či více <span class="emphasis"><em>aktualizačních center</em></span>.
        Standardně jsou nainstalována 4 oficiální centra, která obsahují
        moduly certifikované a testované společností Sun. Uživatel může ale
        přidat libovolná další centra, kterých je na internetu k dispozici
        nepřeberné množství. Při startu NetBeans je pak provedena kontrola
        všech nainstalovaných modulů oproti všem definovaným aktualizačním
        centrům a pokud je nalezena nová verze modulu, je tato nabídnuta ke
        stažení a nainstalování přímo v prostředí NetBeans, bez nutnosti
        manuálního stahování v webových stránek.</p><p>Zároveň není vůbec obtížné nové aktualizační centrum vytvořit.
        Netvoří ho žádná složitá webová aplikace, nýbrž pouze <span class="emphasis"><em>jeden
        konfigurační soubor</em></span>. Ten obsahuje aktuální seznam všech
        modulů, které jsou přes toto centrum dostupné. Vždy je uvedena
        aktuální verze a místo, kde lze daný modul získat. Deskriptor a
        všechny archivy s jednotlivými moduly musejí být veřejně přístupně,
        například přes protokol HTTP. K jednoduchosti celého konceptu přispívá
        i fakt, že NetBeans IDE obsahuje jednoduchého průvodce, který umožňuje
        vytvořit modul, po jehož instalaci je do NetBeans přidáno nové
        aktualizační centrum.</p><p>Pro pokrytí výše popsané funkcionality byl tedy vytvořen nový
        modul pro platformu NetBeans, nezávislý na modulu přidávajícím podporu
        pro rámec Stripes. Tento modul obsahuje jedinou deklaraci v souboru
        layer.xml -- je jí přidání nového aktualizačního centra. Deskriptor
        pro toto centrum je umístěn na stránkách projektu v systému Google
        Code, stejně jako jednotlivé archivy modulu s podporou rámce Stripes.
        Pokud si uživatel stáhne ze stránek projektu modul obsahující
        aktualizační centrum a nainstaluje si ho do svého IDE, nemusí již
        kvůli novým verzím navštěvovat stránky projektu. O nových verzích je
        automaticky informován prostřednictvím svého IDE.</p><p>Nový modul byl rovněž umístěn na server <span class="emphasis"><em>Plugin
        Portal</em></span><a class="indexterm" name="id419611"></a>, tedy do oficiálního úložiště modulů provozovaného
        firmou Sun<sup>[<a href="#ftn.fn_plugin_portal">21</a>]</sup>. Jde o webovou
        aplikaci, která po bezplatné registraci umožňuje uživateli nahrát jím
        vytvořený modul a tím ho zpřístupnit široké veřejnosti. Pro každý
        modul lze zadat jeho popis, klíčová slova a seznam podporovaných verzí
        platformy NetBeans. Zároveň je vytvořen prostor pro diskuzi,
        přihlášení uživatelé mohou přidávat své reakce a zkušenosti s
        instalací či provozem modulu. Tato možnost slouží vývojářům daného
        modulu k získání základní zpětné vazby od zainteresovaných uživatelů.
        Pro jednotlivé moduly je evidován také počet jejich stažení.<sup>[<a name="fn_plugin_portal" href="#ftn.fn_plugin_portal">21</a>]</sup></p></div></div><div class="sect1" lang="cs"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="id419680"></a>Problémy a jejich řešení</h2></div></div></div><p>Při práci na modulu, o němž pojednává tato práce, se vyskytla řada
      překážek, které dosud v textu nebyly zmíněny vůbec či pouze okrajově. Ty
      nejzajímavější z nich shrnuje tato podkapitola.</p><div class="sect2" lang="cs"><div class="titlepage"><div><div><h3 class="title"><a name="id419698"></a>Dialogy pro výběr souboru</h3></div></div></div><p>Na mnoha místech nově vytvořeného modulu je požadováno zadání
        plně kvalifikovaného jména nějaké třídy (například action bean
        instance pro obsluhu formuláře) či cesty k JSP souboru (například
        šabloně rozložení). Vždy je k dispozici klasický textový vstup, do
        kterého je možné požadovaný řetězec vypsat, žádný z těchto ovládacích
        prvků však standardně nenabízí kontextové doplňování konce rozepsaného
        řetězce. Proto byla ke každému takovému vstupu přidána možnost zadat
        soubor jeho zvolením v souborové struktuře projektu.</p><p>Byl tedy vytvořen generický dialog, který ve svém okně zobrazí
        stromovou strukturu zdrojů určitého typu v daném projektu. Inspirace
        byla čerpána ze standardního modulu přidávajícího podporu pro tvorbu a
        editaci HTML souborů. Navíc byla však implementována možnost předat
        dialogu filtr, který je aplikován na zobrazované soubory a složky.
        Pomocí něho je možné zobrazovat pouze soubory určitých přípon či
        určitého obsahu. Bylo implementováno několik filtrů, například pro
        zúžení výběru pouze na JSP stránky, obrázky (.png, .gif., .jpg či
        jinou kolekci grafických souborů) či soubory Java. Navržená
        architektura dává možnost implementovat v budoucnu další typy filtrů a
        tím dále omezit zobrazovanou kolekci souboru. Například nezobrazovat
        všechny soubory Java, ale pouze ty, které obsahují deklaraci nějaké
        <span class="emphasis"><em>action bean</em></span> instance a podobně. Jedna z instancí
        dialogu (zde pro vybrání JSP souboru) je zahrnuta na obrázku <a href="#pic_stripes_templete_usage_wizard" title="Obrázek 5.2. Průvodce vytvořením JSP obsahující využití šablony
          rozložení">5.2 – „Průvodce vytvořením JSP obsahující využití šablony
          rozložení“</a>.</p><p>Pro soubory nacházející se v dokumentové struktuře webové
        aplikace -- tedy například JSP či HTML soubory -- se zdá být navržené
        řešení dostačující. Avšak pro zdrojové Java soubory zřejmě bude nutné
        v budoucnu dialog nahradit jiným řešením. Zde je příklad několika
        důvodů, které k tomuto závěru vedou:</p><div class="itemizedlist"><ul type="disc"><li><p>Dialog může procházet pouze soubory fyzicky se nacházející v
            aktuálním projektu. Často by však bylo užitečné rozsah výběru
            rozšířit na celou <span class="emphasis"><em>ClassPath</em></span> daného projektu,
            tedy zahrnout například veškeré třídy definované v připojených
            knihovnách.</p></li><li><p>Obsah jednotlivých balíků je zobrazován, i když neobsahuje
            žádný soubor Java. K nalezení třídy
            <code class="classname">com.my.web.stripes.action.auth.UserActionBean</code>
            je tak nutné postupně šestkrát levým tlačítkem myši expandovat
            obsah jednotlivých podsložek (<span class="emphasis"><em>com</em></span>,
            <span class="emphasis"><em>com/my</em></span>, <span class="emphasis"><em>com/my/web</em></span> atd.)
            než může být zvolen příslušný zdrojový soubor. A to i přesto, že
            jednotlivé podložky žádné soubory Java neobsahují a bylo by
            rozumné rovnou zobrazit obsah nejvíce zanořené složky -- tedy
            nejvíce specifického balíku.</p></li></ul></div><p>Nejlepším řešením by zřejmě bylo kompletní nahrazení dialogu pro
        soubory Java jiným, který by se choval stejně jako standardní dialog
        <span class="emphasis"><em>Go to Type</em></span>. Ten slouží k otevření zdrojového
        souboru Java zadáním jeho jména (či jeho části). V NetBeans IDE se
        tento dialog zobrazí po stisknutí kombinace kláves <span class="emphasis"><em>Ctrl +
        O</em></span>. Obsahuje celkem tři ovládací prvky. Prvním je textové
        pole, do kterého je možné vepsat název hledané třídy. Ve druhé části
        se vypisuje seznam tříd, které vyhovují zadanému názvu. Posledním
        prvkem dialogu je informační pruh zobrazující umístění aktuálně
        vybrané třídy. Tedy zda se tato nachází mezi zdrojovými soubory
        projektu či pochází z některé z připojených knihoven. Vzhled tohoto
        dialogu ilustruje obrázek <a href="#pic_go_to_type" title="Obrázek 5.8. Návrh budoucího vzhledu dialogu pro výběr souboru
          Java">5.8 – „Návrh budoucího vzhledu dialogu pro výběr souboru
          Java“</a>.</p><div class="figure"><a name="pic_go_to_type"></a><p class="title"><b>Obrázek 5.8. Návrh budoucího vzhledu dialogu pro výběr souboru
          Java</b></p><div class="mediaobject"><table border="0" summary="manufactured viewport for HTML img" cellspacing="0" cellpadding="0" width="488"><tr><td><img src="images/go-to-type-dialog.png" width="488" alt="Návrh budoucího vzhledu dialogu pro výběr souboru Java"></td></tr></table></div></div><p>Otázkou však zůstává, zda by tento nový dialog byl dostatečné
        efektivní a prohledávání netrvalo příliš dlouhou dobu. U velkých
        projektů webových aplikací, které využívají služeb velkého množství
        knihoven, by mohla prohledávaná kolekce Java tříd čítat řádově deseti
        až sta tisíce souborů. I v případě <span class="emphasis"><em>Go to Type</em></span>
        dialogu bylo v minulosti reportováno několik výkonnostních a funkčních
        chyb, není tedy zřejmě jednoduché danou funkcionalitu spolehlivě a
        efektivně implementovat i pro velké kolekce tříd.</p></div><div class="sect2" lang="cs"><div class="titlepage"><div><div><h3 class="title"><a name="id419964"></a>Refactoring</h3></div></div></div><p>V projektu je často nutné, aby se radikálně změnila struktura
        zdrojových souborů. Například se přejmenoval některý z balíků, změnilo
        se umístění dané třídy či některá metoda se přesunula do jiné třídy.
        Takový proces se nazývá <span class="emphasis"><em>refactoring</em></span><a class="indexterm" name="id419985"></a>. Jeho důležitým rysem je, že chování aplikace před a po
        změně se nijak neliší, navenek se chová stále stejně. Ptáte se, jaké
        pohnutky vedou vývojáře k provedení často radikální obměny kódu, aniž
        to má nějaký viditelný efekt? Důvody ke změnám mohou být různé, od
        snahy o větší čitelnost kódu až po naplnění struktury předepsané
        některým z nově použitých návrhových vzorů. Více o tomto tématu a jeho
        abstraktním pozadí lze nalézt v <a href="#bib_REFACT">REFACT</a>.</p><p>Změny by bylo možné provádět i manuálně, vývojář by se ale v
        záplavě tříd často ztratil a nakonec by stejně nedosáhl kýženého
        výsledku. Proto dnešní moderní vývojová prostředí, mezi než se počítá
        i NetBeans IDE, poskytují řadu nástrojů na automatické provedení
        rozsáhlých změn. Struktura projektu se tak může změnit k nepoznání
        během několika vteřin.</p><p>V NetBeans IDE refactoring celkem spolehlivě funguje pro soubory
        Java. Kdybychom podrobněji zkoumali zdrojové soubory modulu, který
        podporu pro refactoring přidává, zjistili bychom, že se jedná téměř
        vždy pouze o posloupnost následujících operací:</p><div class="orderedlist"><ol type="1"><li><p>nalézt všechny výskyty (užití) editované třídy;</p></li><li><p>pokud se mění fyzické umístění souboru (je požadována
            například změna názvu balíku), vykonat danou diskovou
            operaci;</p></li><li><p>provést řadu po sobě následujících operací nahrazení jednoto
            textového řetězce jiným tak, aby výsledný kód vyhovoval zadání a
            byl přeložitelný Java překladačem.</p></li></ol></div><p>Pokud však dojde na refactoring složitějších objektů, vývojové
        prostředí začne selhávat. Je celkem pochopitelné, že nelze refactoring
        provést nad XML či JSP soubory, které obsahují reference na jiné
        soubory či Java třídy. Vyžadovalo by to separátní podporu pro
        jednotlivá DTD či knihovny značek, kterých je nepřeberné množství.
        Celkem zarážející je ovšem fakt, že NetBeans IDE nedokáže spolehlivě
        provést refactoring pro grafické komponenty rámce Swing. Pro tyto má
        IDE velmi rozsáhlou a kvalitní podporu, vývojář je téměř odstíněn od
        psaní zdrojového kódu a pouze využívá připravených průvodců či tvoří
        obsah jednotlivých oken s využitím palety jednotlivých
        komponent.</p><p>Ač jsou všechny komponenty rámce Swing v NetBeans IDE
        zobrazovány vždy jako jeden uzel, fyzicky je tvoří dva soubory: soubor
        Java a XML deskriptor s příponou <span class="emphasis"><em>.form</em></span>. Soubor
        Java obsahuje definici rozložení jednotlivých subkomponent a chování
        ovládacích prvků -- například jaká akce se provede po stisku daného
        tlačítka apod. V XML souboru jsou pak ukládána jednotlivá nastavení
        týkající se vizuální stránky dané komponenty: souřadnice jejího
        umístění v nadřazené komponentě či deklarace umístění, ze kterého
        budou načítány lokalizované popisky jednotlivých textových
        polí.</p><p>V modulu bylo nutné provést refactoring velkého množství
        grafickým komponent, konkrétně konfiguračních dialogů pro jednotlivé
        položky palety. Původní umístění v balíku
        <code class="classname">codesnippets</code> bylo nahrazeno za
        <code class="classname">palette.items</code>, které lépe vyhovuje zvyklostem
        používaným v modulech pro platformu NetBeans. Náhrada se úspěšně
        provedla v souborech Java, avšak obsah XML deskriptorů zůstal
        nedotčen. Bylo tak nutné přejmenovat reference v souborech jinou
        cestou. I v časech grafických aplikací se ukázala síla příkazové
        řádky, stačilo vhodně zkombinovat příkazy <span class="emphasis"><em>find</em></span> a
        <span class="emphasis"><em>sed</em></span>, které se nacházejí v každé standardní
        distribuci operačního systému typu Linux. V operačním systému Windows
        je možné těchto nástrojů využít prostřednictvím konzole
        <span class="emphasis"><em>Cygwin</em></span>. Příkazy, které ve všech deskriptorech
        nahradí původní referenci na balík odkazem novým, mohou mít například
        tento tvar (první řádek slouží k úpravě plně kvalifikovaných jmen,
        druhý ke změně umístění v systému souborů):</p><pre class="programlisting">find . -name "*.form" -exec sed -i 's/\.codesnippets/\.palette\.items/g'\
    {} \;
find . -name "*.form" -exec sed -i 's/\/codesnippets/\/palette\/items/g'\
    {} \;</pre></div><div class="sect2" lang="cs"><div class="titlepage"><div><div><h3 class="title"><a name="id420216"></a>Přechod na platformu NetBeans verze 6.5</h3></div></div></div><p>Pro každý modul stvořený pro platformu NetBeans musí být
        specifikováno, pro jakou verzi platformy a jazyka Java je určen. Java
        verze 6 je dostupná již od prosince roku 2006 a ač prochází neustálými
        opravami (poslední je z března roku 2009), v zásadě se nemění, a proto
        je modul překládán kompilátorem verze 6.0. Při započetí práce na
        modulu (podzim 2008), byla k dispozici stabilní platforma NetBeans
        verze 6.1, a tak byla vybrána jako základ pro implementaci
        modulu.</p><p>Koncem roku 2008 byla vydána platforma NetBeans verze 6.5, proto
        bylo učiněno rozhodnutí o přechodu na novou verzi spolu se zachováním
        kompatibility i s verzí předešlou. Stávající kód ovšem pod novou verzí
        nebylo možné přeložit. Bylo totiž přidáno nové ClassPath API a do něj
        přesunuty třídy, které se týkají dané oblasti, avšak dosud nebyly
        agregovány v jednom modulu. Některé z těchto tříd jsou v modulu rámce
        Stripes využívány, a kvůli tomu nebylo možné přejít na novou platformu
        bez změny v kódu. Zároveň bylo nutné deklarovat závislost na novém
        ClassPath API. To se ovšem ve verzi 6.1 nenachází, a tak daná
        reference nebyla platná.</p><p>Bylo tedy učiněno rozhodnutí platformu verze 6.1 dále
        nepodporovat a soustředit se výhradně na novou verzi 6.5. Hlavním
        důvodem byl fakt, že tato přináší řadu zásadních zlepšení (viditelných
        především v NetBeans IDE) a dá se předpokládat, že dříve nebo později
        na ni všichni uživatelé přejdou. Pokud by existovala významná skupina
        zastánců starší verze, bylo by nutné ve správě verzí vytvořit
        separátní vývojovou větev pro platformu verze 6.1. Prozatím se žádné
        negativní ohlasy na výhradní podporou verze 6.5 neobjevily, a tak
        vývoj pokračuje pouze v jediné verzi.</p><p>V současné době (květen 2009), je již k dispozici platforma
        NetBeans verze 6.7, prozatím však pouze ve verzi
        <span class="emphasis"><em>beta</em></span>. Rozhraní se tak ještě mohou změnit a proto
        zatím nebyl učiněn pokus o sestavení modulu s touto novou platformou.
        Po vydání stabilní verze nové platformy by bylo užitečné možnost
        konverze vyzkoušet a v případě kompatibility podporovat i verzi
        6.7.</p></div><div class="sect2" lang="cs"><div class="titlepage"><div><div><h3 class="title"><a name="id420320"></a>Testování</h3></div></div></div><p>Důležitým úkolem aplikací je poskytnutí spolehlivého provozu. K
        naplnění tohoto úkolu vede několik cest, jednou z nich je tvorba
        testů<a class="indexterm" name="id420334"></a> a jejich spouštění při každé změně kódu. Problematikou
        testování aplikací na různých úrovních se zabývá řada publikací, zde
        probereme pouze ty druhy testů, pomocí nichž je strážena integrita
        chování nového modulu.</p><p>Základním nástrojem k ověření správného fungování vytvořeného
        kódu jsou <span class="emphasis"><em>jednotkové testy</em></span> (<span class="emphasis"><em>unit
        testy</em></span>). Ty jsou vytvářeny pro nejmenší programové celky, v
        případě objektových programovacích jazyků pro jednotlivé třídy a
        jejich metody. K obsluze běhu testů bylo vytvořeno několik testovacích
        rámců, pro jazyk Java lze uvést například <span class="emphasis"><em>JUnit</em></span>
        či <span class="emphasis"><em>TestNG</em></span>. Pro tyto rámce navíc existuje podpora
        ze strany NetBeans IDE, jednotlivé testy lze tak spouštět vyvoláním
        akcí v kontextových menu a výsledky lze procházet v přehledném
        grafickém zobrazení.</p><p>Několik jednotkových testů bylo vytvořeno i pro potřeby
        testování nového modulu, většinou však nebyla jejich aplikace možná.
        Modul je totiž z velké části tvořen grafickými komponentami, na
        jejichž otestování by bylo třeba použít spíše některý z nástrojů na
        <span class="emphasis"><em>funkční testování</em></span> (například <span class="emphasis"><em>IBM
        Rational Functional Tester</em></span>). Jde rovněž o testovací rámce,
        které však na rozdíl od předchozích testují aplikaci prostřednictvím
        jejího grafického rozhraní. Vývojář specifikuje jednotlivé testovací
        scénáře (nejčastěji vytvořením záznamu vlastních akcí provedených nad
        aplikací) a tyto jsou poté prováděny rámcem bez zásahu člověka. Pokud
        se výsledný stav aplikace liší od předpokládaného, daný test je
        označen jako nesplněný. Rámec pracuje na principu simulace pohybu myši
        a stisku jednotlivých tlačítek či kláves.</p><p>Zřejmě nejspolehlivější cestou, jak funkcionalitu modulu ověřit,
        je mít dostatek uživatelů, kteří aktivně modul využívají a sdělují
        vývojářům své problémy případně návrhy na zlepšení. U komerčních
        produktů je běžné, že mezi členy vývojového týmu patří i testeři,
        jejichž jedinou starostí je právě zajištění dostatečného vytížení
        aplikace v typických uživatelských scénářích. Při tvorbě nekomerční
        aplikace je třeba získat testery přímo z řad uživatelů. Nejprve je
        tedy nutné dát aplikaci k dispozici co nejširšímu okruhu zájemců a
        vhodným popisem funkcí je motivovat k vyzkoušení daného programu. A
        dále je nezbytné, aby daní uživatelé měli jednoduchou možnost, jak své
        zkušenosti s programem předat zpět vývojářům.</p><p>K získání testerů pro nový modulu bylo učiněno několik kroků.
        Prvním bylo umístění modulu na <span class="emphasis"><em>Plugin Portal</em></span> --
        za dva a půl měsíce si modul stáhlo tímto způsobem 230 uživatelů. Dále
        je binární verze modulu dostupná ke stažení na stránce projektu v
        systému Google Code, zde se počet stažení prozatím zastavil na čísle
        143. Zároveň 103 uživatelů stáhlo modul aktualizačního centra, přes
        které je rovněž možné Stripes modul získat. Všechny uvedené údaje o
        počtu stažení jsou ze dne 9.5.2009.</p><p>Ke sběru názorů slouží jak diskuze na stránce modulu v systému
        Plugin Portal, tak i -- a to především -- systém na sledování změn na
        stránce projektu v systému Google Code. V obou systémech jsou již
        evidovány reakce uživatelů a nahlášeno několik chyb a návrhů na
        zlepšení.</p></div></div><div class="footnotes"><br><hr width="100" align="left"><div class="footnote"><p><sup>[<a name="ftn.fn_googlecode" href="#fn_googlecode">19</a>] </sup>Systém <span class="emphasis"><em>Google Code</em></span> běží na adrese
            <a href="http://code.google.com/" target="_top">http://code.google.com/</a>.
            Stránky projektu modulu pro rámec Stripes lze navštívit zadáním
            <a href="http://code.google.com/p/stripes4netbeans/" target="_top">http://code.google.com/p/stripes4netbeans/</a>.</p></div><div class="footnote"><p><sup>[<a name="ftn.fn_wiki" href="#fn_wiki">20</a>] </sup><span class="emphasis"><em>Wiki</em></span> je jednoduchá on-line databáze
            znalostí, kterou mohou uživatelé měnit a obohacovat pouze
            prostřednictvím svého webového prohlížeče. Podrobnější definici
            termínu <span class="emphasis"><em>wiki</em></span> lze nalézt například v <a href="#bib_WIKI">WIKI</a>.</p></div><div class="footnote"><p><sup>[<a name="ftn.fn_plugin_portal" href="#fn_plugin_portal">21</a>] </sup>Plugin Portal běží na adrese <a href="http://plugins.netbeans.org/PluginPortal/" target="_top">http://plugins.netbeans.org/</a>.
            Stránka s modulem pro rámec Stripes se nachází na stránce <a href="http://plugins.netbeans.org/PluginPortal/faces/PluginDetailPage.jsp?pluginid=16224" target="_top">http://plugins.netbeans.org/PluginPortal/faces/PluginDetailPage.jsp?pluginid=16224</a>.</p></div></div></div><div class="chapter" lang="cs"><div class="titlepage"><div><div><h2 class="title"><a name="zaver"></a>Kapitola 6. Závěr</h2></div></div></div><p>Cílem této práce bylo vytvoření nového modulu pro platformu
    NetBeans, který by do NetBeans IDE přidal podporu pro webový rámec
    Stripes. Základní verze modulu byla úspěšně navržena a implementována,
    čímž se rámec Stripes zařadil mezi ostatní rozšířené rámce, které v
    NetBeans IDE již podporu mají -- JSF, Spring Web MVC či Wicket. Doufejme,
    že tento krok povede k dalšímu rozšíření uživatelské obce tohoto webového
    rámce. Ten obsahuje mnoho užitečných funkcí a díky své architektuře
    umožňuje širokou škálu využití i integraci s jinými rámci.</p><p>Jak již bylo řečeno, popsaná verze modulu obsahuje pouze základní
    kolekci nástrojů. Vývoj bude pokračovat i nadále, a to jak přidáváním nové
    funkcionality, tak opravou chyb nacházených jednotlivými uživateli. Za
    velmi pozitivní se dá považovat fakt, že kolem modulu se již zformovala
    jistá komunita (čítající stovky uživatelů), od které přicházejí první
    reakce. Tyto lze rozdělit na dva typy: pochvalné ohlasy a hlášení o
    nalezených chybách. První jsou známkou faktu, že nový modul již našel své
    uplatnění a usnadnil vývoj několika webových aplikací. Druhý typ reakcí je
    však ještě důležitější -- znamená totiž, že modul je opravdu důkladně
    používán v nejrůznějších scénářích. Především tyto reakce pak přispívají k
    vylepšování existující funkcionality.</p><p>Dalším možným krokem, který by v budoucnu jistě rozšířil komunitu
    uživatelů, je snaha o zahrnutí modulu do oficiálního aktualizačního centra
    pro NetBeans IDE, či dokonce do standardní distribuce, která je k
    dispozici ke stažení na stránkách firmy Sun. Předtím však musí modul
    projít certifikačních řízením, které provádějí vývojáři firmy Sun. V tomto
    je podrobně zkoumána jak funkcionalita daného modulu, tak úroveň
    zdrojových kódu, pomocí nichž je modul implementován.</p><p>Vedlejším produktem práce bylo vytvoření zkušeností, jak vést
    projekt podobného rozsahu, a předání těchto poznatků prostřednictvím této
    práce. Samozřejmě nejde o cestu jedinou, na internetu se zcela jistě
    nachází i spousta jiných systémů či nástrojů, které zdarma poskytují
    stejné či lepší služby. Práce s všemi popsanými systémy byla však
    bezproblémová a pro potřeby malého projektu zcela dostačující.</p></div><div class="bibliography"><div class="titlepage"><div><div><h2 class="title"><a name="bib"></a>Bibliografie</h2></div></div></div><div class="biblioentry"><a name="bib_CS"></a><p>[<span class="abbrev">CS</span>] <span class="title"><i>Client-server</i>, </span><span class="publisher"><span class="publishername">Wikipedia, </span></span><span class="pubdate">5.5.2009, </span><span class="releaseinfo">URL: <a href="http://en.wikipedia.org/wiki/Client-server" target="_top">http://en.wikipedia.org/wiki/Client-server</a>.</span></p></div><div class="biblioentry"><a name="bib_JSR"></a><p>[<span class="abbrev">JSR</span>] <span class="corpauthor">Sun Microsystems, </span><span class="title"><i>Client-server</i>, </span><span class="publisher"><span class="publishername">Sun Microsystems, </span></span><span class="pubdate">2009, </span><span class="releaseinfo">URL: <a href="http://jcp.org/en/jsr/overview" target="_top">http://jcp.org/en/jsr/overview</a>.</span></p></div><div class="biblioentry"><a name="bib_HTTP"></a><p>[<span class="abbrev">HTTP</span>] <span class="title"><i>Hypertext Transfer Protocol</i>, </span><span class="publisher"><span class="publishername">Wikipedia, </span></span><span class="pubdate">25.4.2009, </span><span class="releaseinfo">URL: <a href="http://cs.wikipedia.org/wiki/HTTP" target="_top">http://cs.wikipedia.org/wiki/HTTP</a>.</span></p></div><div class="biblioentry"><a name="bib_CLLDR"></a><p>[<span class="abbrev">CLLDR</span>] <span class="title"><i>Java Classloader</i>, </span><span class="publisher"><span class="publishername">Wikipedia, </span></span><span class="pubdate">1.5.2009, </span><span class="releaseinfo">URL: <a href="http://en.wikipedia.org/wiki/Classloader" target="_top">http://en.wikipedia.org/wiki/Classloader</a>.</span></p></div><div class="biblioentry"><a name="bib_MIME"></a><p>[<span class="abbrev">MIME</span>] <span class="title"><i>Multipurpose Internet Mail Extensions</i>, </span><span class="publisher"><span class="publishername">Wikipedia, </span></span><span class="pubdate">12.1.2009, </span><span class="releaseinfo">URL: <a href="http://cs.wikipedia.org/wiki/MIME" target="_top">http://cs.wikipedia.org/wiki/MIME</a>.</span></p></div><div class="biblioentry"><a name="bib_FLTR"></a><p>[<span class="abbrev">FLTR</span>] <span class="corpauthor">Sun Microsystems, </span><span class="title"><i>The Essentials of Filters</i>, </span><span class="publisher"><span class="publishername">Sun Microsystems, </span></span><span class="pubdate">2009, </span><span class="releaseinfo">URL: <a href="http://java.sun.com/products/servlet/Filters.html" target="_top">http://java.sun.com/products/servlet/Filters.html</a>.</span></p></div><div class="biblioentry"><a name="bib_JSPSYNT"></a><p>[<span class="abbrev">JSPSYNT</span>] <span class="corpauthor">Oracle Corporation, </span><span class="title"><i>Oracle® Application Server Containers for J2EE Support for
      JavaServer Pages Developer's Guide</i>, </span><span class="publisher"><span class="publishername">Oracle Corporation, </span></span><span class="pubdate">2004, </span><span class="releaseinfo">URL: <a href="http://download.oracle.com/docs/cd/B15904_01/web.1012/b14014/jspxml.htm" target="_top">http://download.oracle.com/docs/cd/B15904_01/web.1012/b14014/jspxml.htm</a>.</span></p></div><div class="biblioentry"><a name="bib_JBNS"></a><p>[<span class="abbrev">JBNS</span>] <span class="title"><i>JavaBean</i>, </span><span class="publisher"><span class="publishername">Wikipedia, </span></span><span class="pubdate">29.4.2009, </span><span class="releaseinfo">URL: <a href="http://en.wikipedia.org/wiki/JavaBeans" target="_top">http://en.wikipedia.org/wiki/JavaBeans</a>.</span></p></div><div class="biblioentry"><a name="bib_EL"></a><p>[<span class="abbrev">EL</span>] <span class="corpauthor">Sun Microsystems, </span><span class="title"><i>Expression Language</i>, </span><span class="publisher"><span class="publishername">Sun Microsystems, </span></span><span class="pubdate">2009, </span><span class="releaseinfo">URL: <a href="http://java.sun.com/j2ee/1.4/docs/tutorial/doc/JSPIntro7.html" target="_top">http://java.sun.com/j2ee/1.4/docs/tutorial/doc/JSPIntro7.html</a>.</span></p></div><div class="biblioentry"><a name="bib_RBNDL"></a><p>[<span class="abbrev">RBNDL</span>] <span class="corpauthor">Sun Microsystems, </span><span class="title"><i>Class ResourceBundle</i>, </span><span class="publisher"><span class="publishername">Sun Microsystems, </span></span><span class="pubdate">2003, </span><span class="releaseinfo">URL: <a href="http://java.sun.com/j2se/1.4.2/docs/api/java/util/ResourceBundle.html" target="_top">http://java.sun.com/j2se/1.4.2/docs/api/java/util/ResourceBundle.html</a>.</span></p></div><div class="biblioentry"><a name="bib_JSTL"></a><p>[<span class="abbrev">JSTL</span>] <span class="corpauthor">Sun Microsystems, </span><span class="title"><i>JavaServer Pages Standard Tag Library</i>, </span><span class="publisher"><span class="publishername">Sun Microsystems, </span></span><span class="pubdate">2009, </span><span class="releaseinfo">URL: <a href="http://java.sun.com/products/jsp/jstl/" target="_top">http://java.sun.com/products/jsp/jstl/</a>.</span></p></div><div class="biblioentry"><a name="bib_JSTLTUT"></a><p>[<span class="abbrev">JSTLTUT</span>] <span class="corpauthor">Sun Microsystems, </span><span class="title"><i>Tag Libraries Tutorial (v. 1.0)</i>, </span><span class="publisher"><span class="publishername">Sun Microsystems, </span></span><span class="pubdate">2000, </span><span class="releaseinfo">URL: <a href="http://java.sun.com/products/jsp/tutorial/TagLibrariesTOC.html" target="_top">http://java.sun.com/products/jsp/tutorial/TagLibrariesTOC.html</a>.</span></p></div><div class="biblioentry"><a name="bib_WFWRKS"></a><p>[<span class="abbrev">WFWRKS</span>] <span class="corpauthor">java-source.net, </span><span class="title"><i>Open Source Web Frameworks in Java</i>, </span><span class="publisher"><span class="publishername">java-source.net, </span></span><span class="pubdate">2000, </span><span class="releaseinfo">URL: <a href="http://java-source.net/open-source/web-frameworks" target="_top">http://java-source.net/open-source/web-frameworks</a>.</span></p></div><div class="biblioentry"><a name="bib_ANOT"></a><p>[<span class="abbrev">ANOT</span>] <span class="corpauthor">Sun Microsystems, </span><span class="title"><i>Annotations</i>, </span><span class="publisher"><span class="publishername">Sun Microsystems, </span></span><span class="pubdate">2004, </span><span class="releaseinfo">URL: <a href="http://java.sun.com/j2se/1.5.0/docs/guide/language/annotations.html" target="_top">http://java.sun.com/j2se/1.5.0/docs/guide/language/annotations.html</a>.</span></p></div><div class="biblioentry"><a name="bib_SEO"></a><p>[<span class="abbrev">SEO</span>] <span class="title"><i>Search Engine Optimization</i>, </span><span class="publisher"><span class="publishername">Wikipedia, </span></span><span class="pubdate">18.4.2009, </span><span class="releaseinfo">URL: <a href="http://cs.wikipedia.org/wiki/Search_Engine_Optimization" target="_top">http://cs.wikipedia.org/wiki/Search_Engine_Optimization</a>.</span></p></div><div class="biblioentry"><a name="bib_ORM"></a><p>[<span class="abbrev">ORM</span>] <span class="title"><i>Object-relational mapping</i>, </span><span class="publisher"><span class="publishername">Wikipedia, </span></span><span class="pubdate">5.5.2009, </span><span class="releaseinfo">URL: <a href="http://en.wikipedia.org/wiki/Object-relational_mapping" target="_top">http://en.wikipedia.org/wiki/Object-relational_mapping</a>.</span></p></div><div class="biblioentry"><a name="bib_DP"></a><p>[<span class="abbrev">DP</span>] <span class="title"><i>Design pattern (computer science)</i>, </span><span class="publisher"><span class="publishername">Wikipedia, </span></span><span class="pubdate">6.5.2009, </span><span class="releaseinfo">URL: <a href="http://en.wikipedia.org/wiki/Design_pattern_(computer_science)" target="_top">http://en.wikipedia.org/wiki/Design_pattern_(computer_science)</a>.</span></p></div><div class="biblioentry"><a name="bib_JSF"></a><p>[<span class="abbrev">JSF</span>] <span class="title"><i>JavaServer Faces</i>, </span><span class="publisher"><span class="publishername">Wikipedia, </span></span><span class="pubdate">28.1.2009, </span><span class="releaseinfo">URL: <a href="http://cs.wikipedia.org/wiki/JavaServer_Faces" target="_top">http://cs.wikipedia.org/wiki/JavaServer_Faces</a>.</span></p></div><div class="biblioentry"><a name="bib_JSFVWIC"></a><p>[<span class="abbrev">JSFVWIC</span>] <span class="title"><i>Seam / JSF vs Wicket: performance comparison</i>, </span><span class="author"><span class="firstname">Peter</span> <span class="surname">Thomas</span>: </span><span class="publisher"><span class="publishername">WordPress, </span></span><span class="pubdate">14.1.2009, </span><span class="releaseinfo">URL: <a href="http://ptrthomas.wordpress.com/2009/01/14/seam-jsf-vs-wicket-performance-comparison/" target="_top">http://ptrthomas.wordpress.com/2009/01/14/seam-jsf-vs-wicket-performance-comparison/</a>.</span></p></div><div class="biblioentry"><a name="bib_TAP"></a><p>[<span class="abbrev">TAP</span>] <span class="title"><i>Welcome to Apache Tapestry</i>, </span><span class="corpauthor">Apache Software Foundation, </span><span class="publisher"><span class="publishername">Apache Software Foundation, </span></span><span class="pubdate">2009, </span><span class="releaseinfo">URL: <a href="http://tapestry.apache.org/" target="_top">http://tapestry.apache.org/</a>.</span></p></div><div class="biblioentry"><a name="bib_WIC"></a><p>[<span class="abbrev">WIC</span>] <span class="title"><i>Welcome to Apache Wicket</i>, </span><span class="corpauthor">Apache Software Foundation, </span><span class="publisher"><span class="publishername">Apache Software Foundation, </span></span><span class="pubdate">2009, </span><span class="releaseinfo">URL: <a href="http://wicket.apache.org/" target="_top">http://wicket.apache.org/</a>.</span></p></div><div class="biblioentry"><a name="bib_STR"></a><p>[<span class="abbrev">STR</span>] <span class="title"><i>Apache Struts</i>, </span><span class="corpauthor">Apache Software Foundation, </span><span class="publisher"><span class="publishername">Apache Software Foundation<a href="http://struts.apache.org/" target="_top">http://struts.apache.org/</a>, </span></span><span class="pubdate">2009, </span><span class="releaseinfo">URL: <a href="http://struts.apache.org/" target="_top">http://struts.apache.org/</a>.</span></p></div><div class="biblioentry"><a name="bib_STRFI"></a><p>[<span class="abbrev">STRFI</span>] <span class="title"><i>Apache Struts</i>, </span><span class="author"><span class="firstname">Martin</span> <span class="surname">Kuba</span>: </span><span class="publisher"><span class="publishername">Fakulta Informatiky MU, </span></span><span class="pubdate">2009, </span><span class="releaseinfo">URL: <a href="http://kore.fi.muni.cz:5080/wiki/index.php/Apache_Struts" target="_top">http://kore.fi.muni.cz:5080/wiki/index.php/Apache_Struts</a>.</span></p></div><div class="biblioentry"><a name="bib_IOC"></a><p>[<span class="abbrev">IOC</span>] <span class="title"><i>Inversion of control</i>, </span><span class="publisher"><span class="publishername">Wikipedia, </span></span><span class="pubdate">5.5.2009, </span><span class="releaseinfo">URL: <a href="http://en.wikipedia.org/wiki/Inversion_of_control" target="_top">http://en.wikipedia.org/wiki/Inversion_of_control</a>.</span></p></div><div class="biblioentry"><a name="bib_AOP"></a><p>[<span class="abbrev">AOP</span>] <span class="title"><i>Aspect-oriented programming</i>, </span><span class="publisher"><span class="publishername">Wikipedia, </span></span><span class="pubdate">11.4.2009, </span><span class="releaseinfo">URL: <a href="http://en.wikipedia.org/wiki/Aspect-oriented_programming" target="_top">http://en.wikipedia.org/wiki/Aspect-oriented_programming</a>.</span></p></div><div class="biblioentry"><a name="bib_PORT"></a><p>[<span class="abbrev">PORT</span>] <span class="title"><i>Portlet</i>, </span><span class="publisher"><span class="publishername">Wikipedia, </span></span><span class="pubdate">18.3.2009, </span><span class="releaseinfo">URL: <a href="http://en.wikipedia.org/wiki/Portlet" target="_top">http://en.wikipedia.org/wiki/Portlet</a>.</span></p></div><div class="biblioentry"><a name="bib_SPRING"></a><p>[<span class="abbrev">SPRING</span>] <span class="title"><i>Web MVC framework</i>, </span><span class="authorgroup"><span class="firstname">Rod</span> <span class="surname">Johnson</span>, <span class="firstname">Juergen</span> <span class="surname">Hoeller</span>, <span class="firstname">Alef</span> <span class="surname">Arendsen</span>, <span class="firstname">Colin</span> <span class="surname">Sampaleanu</span>, and <span class="firstname">Rob</span> <span class="surname">Harrop</span>: </span><span class="publisher"><span class="publishername">SpringSource, </span></span><span class="pubdate">2006, </span><span class="releaseinfo">URL: <a href="http://static.springframework.org/spring/docs/2.5.x/reference/mvc.html" target="_top">http://static.springframework.org/spring/docs/2.5.x/reference/mvc.html</a>.</span></p></div><div class="biblioentry"><a name="bib_STRDOC"></a><p>[<span class="abbrev">STRDOC</span>] <span class="title"><i>Stripes 1.5.1 API Documentation</i>, </span><span class="corpauthor">Stripes Development Team, </span><span class="publisher"><span class="publishername">SourceForge, </span></span><span class="pubdate">2009, </span><span class="releaseinfo">URL: <a href="http://stripes.sourceforge.net/docs/current/javadoc/" target="_top">http://stripes.sourceforge.net/docs/current/javadoc/</a>.</span></p></div><div class="biblioentry"><a name="bib_STRSITE"></a><p>[<span class="abbrev">STRSITE</span>] <span class="title"><i>Welcome to Stripes!</i>, </span><span class="corpauthor">Stripes Development Team, </span><span class="publisher"><span class="publishername">Stripes Development Team, </span></span><span class="pubdate">2009, </span><span class="releaseinfo">URL: <a href="http://www.stripesframework.org/" target="_top">http://www.stripesframework.org/</a>.</span></p></div><div class="biblioentry"><a name="bib_STRIPESFI"></a><p>[<span class="abbrev">STRIPESFI</span>] <span class="title"><i>Stripes</i>, </span><span class="author"><span class="firstname">Martin</span> <span class="surname">Kuba</span>: </span><span class="publisher"><span class="publishername">Fakulta Informatiky MU, </span></span><span class="pubdate">2009, </span><span class="releaseinfo">URL: <a href="http://kore.fi.muni.cz:5080/wiki/index.php/Stripes" target="_top">http://kore.fi.muni.cz:5080/wiki/index.php/Stripes</a>.</span></p></div><div class="biblioentry"><a name="bib_CDDL"></a><p>[<span class="abbrev">CDDL</span>] <span class="title"><i>COMMON DEVELOPMENT AND DISTRIBUTION LICENSE (CDDL) Version
      1.0</i>, </span><span class="corpauthor">Sun Microsystems, </span><span class="publisher"><span class="publishername">Sun Microsystems, </span></span><span class="releaseinfo">URL: <a href="http://www.sun.com/cddl/cddl.html" target="_top">http://www.sun.com/cddl/cddl.html</a>.</span></p></div><div class="biblioentry"><a name="bib_NBTUT"></a><p>[<span class="abbrev">NBTUT</span>] <span class="title"><i>NetBeans Platform Learning Trail</i>, </span><span class="corpauthor">Sun Microsystems, </span><span class="publisher"><span class="publishername">Sun Microsystems, </span></span><span class="releaseinfo">URL: <a href="http://www.netbeans.org/kb/trails/platform.html" target="_top">http://www.netbeans.org/kb/trails/platform.html</a>.</span></p></div><div class="biblioentry"><a name="bib_WIKI"></a><p>[<span class="abbrev">WIKI</span>] <span class="title"><i>What Is Wiki</i>, </span><span class="authorgroup"><span class="firstname">Bo</span> <span class="surname">Leuf</span> and <span class="firstname">Ward</span> <span class="surname">Cunningham</span>: </span><span class="pubdate">9.6.2002, </span><span class="releaseinfo">URL: <a href="http://wiki.org/wiki.cgi?WhatIsWiki" target="_top">http://wiki.org/wiki.cgi?WhatIsWiki</a>.</span></p></div><div class="biblioentry"><a name="bib_GCUP"></a><p>[<span class="abbrev">GCUP</span>] <span class="title"><i>Upload binaries to Google Code using Ant</i>, </span><span class="pubdate">26.4.2009, </span><span class="releaseinfo">URL: <a href="http://code.google.com/p/ant-googlecode/" target="_top">http://code.google.com/p/ant-googlecode/</a>.</span></p></div><div class="biblioentry"><a name="bib_REFACT"></a><p>[<span class="abbrev">REFACT</span>] <span class="title"><i>Code refactoring</i>, </span><span class="publisher"><span class="publishername">Wikipedia, </span></span><span class="pubdate">6.5.2009, </span><span class="releaseinfo">URL: <a href="http://en.wikipedia.org/wiki/Refactoring" target="_top">http://en.wikipedia.org/wiki/Refactoring</a>.</span></p></div></div><div class="index"><div class="titlepage"><div><div><h2 class="title"><a name="id422218"></a>Rejstřík</h2></div></div></div><div class="index"><div class="indexdiv"><h3>D</h3><dl><dt>deployment deskriptor, <a href="#dd">Deployment deskriptor</a></dt></dl></div><div class="indexdiv"><h3>F</h3><dl><dt>filtr, <a href="#id408443">Filtr</a></dt></dl></div><div class="indexdiv"><h3>G</h3><dl><dt>Google Code, <a href="#id419137">Řízení projektu</a></dt></dl></div><div class="indexdiv"><h3>H</h3><dl><dt>HTTP protokol (Viz protokol HTTP)</dt></dl></div><div class="indexdiv"><h3>J</h3><dl><dt>Java Server Pages, <a href="#jsp">Java Server Pages</a></dt><dd><dl><dt>Expression Language, <a href="#id409275">Dynamický obsah JSP stránek</a></dt><dt>knihovny značek, <a href="#taglibs">Knihovny značek</a></dt><dt>syntax, <a href="#id408764">Srovnání přípustných formátů JSP</a>, <a href="#id408963">Standardní syntax JSP</a></dt></dl></dd><dt>Java Servlet API, <a href="#servlets">Java Servlet API</a></dt><dt>JSF, <a href="#id410987">Java Server Faces</a></dt><dt>JSP (Viz Java Server Pages)</dt><dt>JSTL, <a href="#taglibs">Knihovny značek</a></dt></dl></div><div class="indexdiv"><h3>K</h3><dl><dt>kontejner, <a href="#id342858">Běhové prostředí -- kontejnery</a></dt></dl></div><div class="indexdiv"><h3>M</h3><dl><dt>MVC, <a href="#mvc">Architektura MVC</a></dt></dl></div><div class="indexdiv"><h3>N</h3><dl><dt>NetBeans</dt><dd><dl><dt>API, <a href="#id415968">API použitá pro tvorbu nového modulu</a></dt><dt>IDE, <a href="#id418994">NetBeans IDE</a></dt><dt>RCP, <a href="#netbeans_RCP">NetBeans RCP</a></dt><dt>Update Center, <a href="#id419408">Publikování nových verzí modulu</a></dt></dl></dd><dt>NetBeans Plugin Portal, <a href="#id419408">Publikování nových verzí modulu</a></dt></dl></div><div class="indexdiv"><h3>P</h3><dl><dt>protokol HTTP, <a href="#http">Protokol HTTP</a></dt></dl></div><div class="indexdiv"><h3>R</h3><dl><dt>refactoring, <a href="#id419964">Refactoring</a></dt><dt>projektové řízení, <a href="#id419137">Řízení projektu</a></dt></dl></div><div class="indexdiv"><h3>S</h3><dl><dt>servlet, <a href="#servlet">Servlet</a></dt><dd><dl><dt>životní cyklus, <a href="#id408122">Životní cyklus servletu</a></dt></dl></dd><dt>Spring Web MVC, <a href="#id412310">Spring Web MVC</a></dt><dt>Stripes, <a href="#stripes">Rámec Stripes</a>, <a href="#impl">Implementace zásuvného modulu</a></dt><dd><dl><dt>action beans, <a href="#id413052">Action beans</a></dt><dt>akce, <a href="#bean_actions">Volba vyvolané akce</a></dt><dt>knihovna značek, <a href="#stripes_taglib">Knihovna značek Stripes</a></dt><dt>mapování požadavků, <a href="#obsluha_pozadavku">Obsluha požadavků</a></dt><dt>validace dat, <a href="#id_phase_bindandvalid">Validace dat</a></dt><dt>vázání parametrů, <a href="#param_bind">Vázání parametrů z požadavku</a></dt><dt>šablony, <a href="#id415355">Možnosti tvorby šablon</a></dt></dl></dd><dt>Struts, <a href="#id411850">Struts</a></dt><dt>Subversion, <a href="#id419137">Řízení projektu</a></dt><dt>Swing, <a href="#id410987">Java Server Faces</a>, <a href="#netbeans_RCP">NetBeans RCP</a></dt></dl></div><div class="indexdiv"><h3>T</h3><dl><dt>Tapestry, <a href="#id411384">Tapestry</a></dt><dt>testování aplikací, <a href="#id420320">Testování</a></dt></dl></div><div class="indexdiv"><h3>W</h3><dl><dt>web.xml (Viz deployment deskriptor)</dt><dt>webová aplikace, <a href="#webapps">Definice webové aplikace</a></dt><dd><dl><dt>definice, <a href="#webapps">Definice webové aplikace</a></dt><dt>prezentační, <a href="#webapps">Definice webové aplikace</a>, <a href="#pres_webapps">Prezentační webové aplikace</a></dt><dt>příklad, <a href="#pres_webapps">Prezentační webové aplikace</a></dt><dt>servisní, <a href="#webapps">Definice webové aplikace</a></dt></dl></dd><dt>webový rámec, <a href="#id409986">Webové aplikační rámce</a></dt><dd><dl><dt>komponentový, <a href="#id410872">Rámce založené na komponentách</a></dt><dt>poskytované služby, <a href="#id340541">Typicky poskytované služby</a></dt><dt>založený na akcích, <a href="#id411781">Rámce založené na akcích</a></dt></dl></dd><dt>Wicket, <a href="#id411602">Wicket</a></dt><dt>wiki, <a href="#id419137">Řízení projektu</a></dt></dl></div></div></div></div></body></html>
